trinity-cli 0.1.0__py3-none-any.whl

trinity_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Trinity CLI — command-line interface for the Trinity Agent Platform."""
+
+__version__ = "0.1.0"

trinity_cli/client.py

@@ -0,0 +1,107 @@
+"""HTTP client for the Trinity Backend API."""
+
+import sys
+from typing import Any, Optional
+
+import click
+import httpx
+
+from .config import get_api_key, get_instance_url
+
+
+def _profile_from_context() -> Optional[str]:
+    """Try to get the --profile value from the current Click context."""
+    try:
+        ctx = click.get_current_context(silent=True)
+        if ctx:
+            root = ctx.find_root()
+            if root.obj and "profile" in root.obj:
+                return root.obj["profile"]
+    except RuntimeError:
+        pass
+    return None
+
+
+class TrinityAPIError(Exception):
+    def __init__(self, status_code: int, detail: str):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class TrinityClient:
+    """Thin HTTP wrapper around the Trinity FastAPI backend."""
+
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None,
+                 profile: Optional[str] = None):
+        resolved_profile = profile or _profile_from_context()
+        self.base_url = base_url or get_instance_url(resolved_profile)
+        self.token = token or get_api_key(resolved_profile)
+        if not self.base_url:
+            print("Error: No Trinity instance configured. Run 'trinity init' or 'trinity login' first.", file=sys.stderr)
+            sys.exit(1)
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.token:
+            h["Authorization"] = f"Bearer {self.token}"
+        return h
+
+    def _handle_response(self, resp: httpx.Response) -> Any:
+        if resp.status_code == 401:
+            print("Error: Authentication failed. Run 'trinity login' to re-authenticate.", file=sys.stderr)
+            sys.exit(1)
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise TrinityAPIError(resp.status_code, str(detail))
+        if resp.status_code == 204:
+            return None
+        return resp.json()
+
+    def get(self, path: str, params: Optional[dict] = None) -> Any:
+        with httpx.Client(timeout=30) as c:
+            resp = c.get(f"{self.base_url}{path}", headers=self._headers(), params=params)
+            return self._handle_response(resp)
+
+    def post(self, path: str, json: Optional[dict] = None) -> Any:
+        with httpx.Client(timeout=60) as c:
+            resp = c.post(f"{self.base_url}{path}", headers=self._headers(), json=json)
+            return self._handle_response(resp)
+
+    def put(self, path: str, json: Optional[dict] = None) -> Any:
+        with httpx.Client(timeout=30) as c:
+            resp = c.put(f"{self.base_url}{path}", headers=self._headers(), json=json)
+            return self._handle_response(resp)
+
+    def delete(self, path: str) -> Any:
+        with httpx.Client(timeout=30) as c:
+            resp = c.delete(f"{self.base_url}{path}", headers=self._headers())
+            return self._handle_response(resp)
+
+    def post_form(self, path: str, data: dict) -> Any:
+        """POST with form-encoded body (for OAuth2 token endpoint)."""
+        with httpx.Client(timeout=30) as c:
+            headers = {}
+            if self.token:
+                headers["Authorization"] = f"Bearer {self.token}"
+            resp = c.post(f"{self.base_url}{path}", data=data, headers=headers)
+            return self._handle_response(resp)
+
+    def post_unauthenticated(self, path: str, json: Optional[dict] = None) -> Any:
+        """POST without auth header (for login/registration flows)."""
+        with httpx.Client(timeout=30) as c:
+            resp = c.post(
+                f"{self.base_url}{path}",
+                headers={"Content-Type": "application/json"},
+                json=json,
+            )
+            return self._handle_response(resp)
+
+    def get_unauthenticated(self, path: str) -> Any:
+        """GET without auth header."""
+        with httpx.Client(timeout=30) as c:
+            resp = c.get(f"{self.base_url}{path}")
+            return self._handle_response(resp)

trinity_cli/commands/agents.py

@@ -0,0 +1,96 @@
+"""Agent management commands."""
+
+import click
+
+from ..client import TrinityClient, TrinityAPIError
+from ..output import format_output
+
+
+@click.group()
+def agents():
+    """Manage agents."""
+    pass
+
+
+@agents.command("list")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def list_agents(fmt):
+    """List all agents."""
+    client = TrinityClient()
+    data = client.get("/api/agents")
+    if fmt == "table" and isinstance(data, list):
+        # Slim down for table view
+        rows = [
+            {
+                "name": a.get("name", ""),
+                "status": a.get("status", ""),
+                "template": a.get("template", ""),
+                "type": a.get("type", ""),
+            }
+            for a in data
+        ]
+        format_output(rows, fmt)
+    else:
+        format_output(data, fmt)
+
+
+@agents.command("get")
+@click.argument("name")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def get_agent(name, fmt):
+    """Get agent details."""
+    client = TrinityClient()
+    data = client.get(f"/api/agents/{name}")
+    format_output(data, fmt)
+
+
+@agents.command("create")
+@click.argument("name")
+@click.option("--template", default=None, help="Template (e.g. github:Org/repo)")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def create_agent(name, template, fmt):
+    """Create a new agent."""
+    client = TrinityClient()
+    payload = {"name": name}
+    if template:
+        payload["template"] = template
+    data = client.post("/api/agents", json=payload)
+    format_output(data, fmt)
+
+
+@agents.command("delete")
+@click.argument("name")
+@click.confirmation_option(prompt="Are you sure you want to delete this agent?")
+def delete_agent(name):
+    """Delete an agent."""
+    client = TrinityClient()
+    client.delete(f"/api/agents/{name}")
+    click.echo(f"Deleted agent '{name}'")
+
+
+@agents.command("start")
+@click.argument("name")
+def start_agent(name):
+    """Start an agent container."""
+    client = TrinityClient()
+    client.post(f"/api/agents/{name}/start")
+    click.echo(f"Started agent '{name}'")
+
+
+@agents.command("stop")
+@click.argument("name")
+def stop_agent(name):
+    """Stop an agent container."""
+    client = TrinityClient()
+    client.post(f"/api/agents/{name}/stop")
+    click.echo(f"Stopped agent '{name}'")
+
+
+@agents.command("rename")
+@click.argument("name")
+@click.argument("new_name")
+def rename_agent(name, new_name):
+    """Rename an agent."""
+    client = TrinityClient()
+    client.put(f"/api/agents/{name}/rename", json={"new_name": new_name})
+    click.echo(f"Renamed '{name}' -> '{new_name}'")

trinity_cli/commands/auth.py

@@ -0,0 +1,177 @@
+"""Authentication commands: login, logout, status, init."""
+
+import click
+
+from ..client import TrinityClient, TrinityAPIError
+from ..config import (
+    clear_auth, get_instance_url, get_user, load_config,
+    profile_name_from_url, set_auth, _resolve_profile_name,
+)
+
+
+def _get_profile_name(ctx: click.Context) -> str | None:
+    """Extract the --profile value from the root context."""
+    root = ctx.find_root()
+    return root.obj.get("profile") if root.obj else None
+
+
+@click.command()
+@click.option("--instance", help="Trinity instance URL (e.g. https://trinity.example.com)")
+@click.option("--profile", "profile_opt", default=None,
+              help="Profile name to store credentials under (default: hostname)")
+@click.pass_context
+def login(ctx, instance, profile_opt):
+    """Log in to a Trinity instance with email verification."""
+    profile_name = profile_opt or _get_profile_name(ctx)
+    url = instance or get_instance_url(profile_name)
+    if not url:
+        url = click.prompt("Trinity instance URL")
+    url = url.rstrip("/")
+
+    client = TrinityClient(base_url=url, token="none")
+
+    email = click.prompt("Email")
+
+    # Request verification code
+    try:
+        client.post_unauthenticated("/api/auth/email/request", {"email": email})
+    except TrinityAPIError as e:
+        click.echo(f"Error requesting code: {e.detail}", err=True)
+        raise SystemExit(1)
+
+    click.echo(f"Verification code sent to {email}")
+    code = click.prompt("Enter 6-digit code")
+
+    # Verify code and get token
+    try:
+        result = client.post_unauthenticated("/api/auth/email/verify", {
+            "email": email,
+            "code": code,
+        })
+    except TrinityAPIError as e:
+        click.echo(f"Verification failed: {e.detail}", err=True)
+        raise SystemExit(1)
+
+    token = result["access_token"]
+    user = result.get("user")
+
+    # Determine profile name: explicit > global flag > derive from URL
+    target_profile = profile_name or profile_name_from_url(url)
+    set_auth(url, token, user, profile_name=target_profile)
+    name = user.get("name") or user.get("email") or user.get("username") if user else email
+    click.echo(f"Logged in as {name} [profile: {target_profile}]")
+
+
+@click.command()
+@click.pass_context
+def logout(ctx):
+    """Clear stored credentials for the current profile."""
+    profile_name = _get_profile_name(ctx)
+    clear_auth(profile_name)
+    resolved = _resolve_profile_name(profile_name)
+    click.echo(f"Logged out [profile: {resolved}]")
+
+
+@click.command()
+@click.pass_context
+def status(ctx):
+    """Show current login status and instance info."""
+    profile_name = _get_profile_name(ctx)
+    resolved = _resolve_profile_name(profile_name)
+    url = get_instance_url(profile_name)
+
+    click.echo(f"Profile:  {resolved}")
+
+    if not url:
+        click.echo("Instance: Not configured. Run 'trinity init' or 'trinity login'.")
+        return
+
+    user = get_user(profile_name)
+    config = load_config()
+    profile_data = config.get("profiles", {}).get(resolved, {})
+
+    click.echo(f"Instance: {url}")
+    if user:
+        click.echo(f"User:     {user.get('email') or user.get('username')}")
+        click.echo(f"Role:     {user.get('role', 'unknown')}")
+    elif profile_data.get("token"):
+        click.echo("User:     (API key auth)")
+    else:
+        click.echo("User:     Not logged in")
+
+    # Check connectivity
+    try:
+        client = TrinityClient(base_url=url, token=profile_data.get("token", "none"))
+        client.get_unauthenticated("/api/auth/mode")
+        click.echo("Status:   Connected")
+    except Exception:
+        click.echo("Status:   Unreachable")
+
+
+@click.command()
+@click.option("--profile", "profile_opt", default=None,
+              help="Profile name (default: derived from instance hostname)")
+@click.pass_context
+def init(ctx, profile_opt):
+    """Set up Trinity CLI: configure instance, request access, and log in.
+
+    One command to go from zero to authenticated. Creates a named profile
+    for the instance (defaults to hostname).
+    """
+    url = click.prompt("Trinity instance URL", default="http://localhost:8000")
+    url = url.rstrip("/")
+
+    client = TrinityClient(base_url=url, token="none")
+
+    # Verify instance is reachable
+    try:
+        client.get_unauthenticated("/api/auth/mode")
+    except Exception:
+        click.echo(f"Cannot reach {url}. Check the URL and try again.", err=True)
+        raise SystemExit(1)
+
+    click.echo(f"Connected to {url}")
+
+    # Determine profile name
+    profile_name = profile_opt or _get_profile_name(ctx) or profile_name_from_url(url)
+
+    email = click.prompt("Email")
+
+    # Request access (auto-approve endpoint)
+    try:
+        client.post_unauthenticated("/api/access/request", {"email": email})
+        click.echo("Access granted")
+    except TrinityAPIError as e:
+        if e.status_code == 409:
+            click.echo("Already registered")
+        else:
+            click.echo(f"Access request failed: {e.detail}", err=True)
+            raise SystemExit(1)
+
+    # Send verification code
+    try:
+        client.post_unauthenticated("/api/auth/email/request", {"email": email})
+    except TrinityAPIError as e:
+        click.echo(f"Error requesting code: {e.detail}", err=True)
+        raise SystemExit(1)
+
+    click.echo(f"Verification code sent to {email}")
+    code = click.prompt("Enter 6-digit code")
+
+    # Verify and get token
+    try:
+        result = client.post_unauthenticated("/api/auth/email/verify", {
+            "email": email,
+            "code": code,
+        })
+    except TrinityAPIError as e:
+        click.echo(f"Verification failed: {e.detail}", err=True)
+        raise SystemExit(1)
+
+    token = result["access_token"]
+    user = result.get("user")
+
+    set_auth(url, token, user, profile_name=profile_name)
+    name = user.get("name") or user.get("email") or user.get("username") if user else email
+    click.echo(f"Logged in as {name} [profile: {profile_name}]")
+    click.echo(f"\nTrinity CLI is ready. Try 'trinity agents list'.")

trinity_cli/commands/chat.py

@@ -0,0 +1,64 @@
+"""Chat and log commands."""
+
+import click
+
+from ..client import TrinityClient
+from ..output import format_output
+
+
+@click.command("chat")
+@click.argument("agent")
+@click.argument("message")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def chat_with_agent(agent, message, fmt):
+    """Send a message to an agent.
+
+    Example: trinity chat my-agent "What is the status?"
+    """
+    client = TrinityClient()
+    data = client.post(f"/api/agents/{agent}/chat", json={"message": message})
+    if fmt == "json":
+        format_output(data, fmt)
+    else:
+        # In table mode, just print the response text
+        response = data.get("response", data) if isinstance(data, dict) else data
+        click.echo(response)
+
+
+@click.group("chat-history")
+def chat_history_group():
+    """Chat history commands."""
+    pass
+
+
+@click.command("history")
+@click.argument("agent")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def chat_history(agent, fmt):
+    """Get chat history for an agent."""
+    client = TrinityClient()
+    data = client.get(f"/api/agents/{agent}/chat/history")
+    format_output(data, fmt)
+
+
+@click.command("logs")
+@click.argument("agent")
+@click.option("--tail", default=50, help="Number of log lines")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def logs(agent, tail, fmt):
+    """View agent container logs.
+
+    Example: trinity logs my-agent --tail 100
+    """
+    client = TrinityClient()
+    data = client.get(f"/api/agents/{agent}/logs", params={"tail": tail})
+    if fmt == "json":
+        format_output(data, fmt)
+    else:
+        # Print logs as plain text
+        if isinstance(data, dict) and "logs" in data:
+            click.echo(data["logs"])
+        elif isinstance(data, str):
+            click.echo(data)
+        else:
+            format_output(data, fmt)

trinity_cli/commands/health.py

@@ -0,0 +1,31 @@
+"""Health and monitoring commands."""
+
+import click
+
+from ..client import TrinityClient
+from ..output import format_output
+
+
+@click.group()
+def health():
+    """Fleet and agent health monitoring."""
+    pass
+
+
+@health.command("fleet")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def fleet_health(fmt):
+    """Show fleet-wide health status."""
+    client = TrinityClient()
+    data = client.get("/api/monitoring/status")
+    format_output(data, fmt)
+
+
+@health.command("agent")
+@click.argument("name")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def agent_health(name, fmt):
+    """Show health status for a specific agent."""
+    client = TrinityClient()
+    data = client.get(f"/api/monitoring/agents/{name}")
+    format_output(data, fmt)

trinity_cli/commands/profiles.py

@@ -0,0 +1,57 @@
+"""Profile management commands: list, use, remove."""
+
+import click
+
+from ..config import list_profiles, remove_profile, set_current_profile
+from ..output import format_output
+
+
+@click.group()
+def profile():
+    """Manage instance profiles.
+
+    Profiles let you store credentials for multiple Trinity instances
+    and switch between them.
+    """
+    pass
+
+
+@profile.command("list")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="table",
+              help="Output format")
+def profile_list(fmt):
+    """List all configured profiles."""
+    profiles = list_profiles()
+    if not profiles:
+        click.echo("No profiles configured. Run 'trinity init' to create one.")
+        return
+
+    if fmt == "json":
+        format_output(profiles, "json")
+    else:
+        for p in profiles:
+            marker = "*" if p["active"] else " "
+            user_str = f" ({p['user']})" if p["user"] else ""
+            click.echo(f"  {marker} {p['name']:20s} {p['instance_url']}{user_str}")
+
+
+@profile.command("use")
+@click.argument("name")
+def profile_use(name):
+    """Switch to a different profile."""
+    if set_current_profile(name):
+        click.echo(f"Switched to profile '{name}'")
+    else:
+        click.echo(f"Profile '{name}' not found. Run 'trinity profile list' to see available profiles.", err=True)
+        raise SystemExit(1)
+
+
+@profile.command("remove")
+@click.argument("name")
+def profile_remove(name):
+    """Remove a profile."""
+    if remove_profile(name):
+        click.echo(f"Removed profile '{name}'")
+    else:
+        click.echo(f"Profile '{name}' not found.", err=True)
+        raise SystemExit(1)

trinity_cli/commands/schedules.py

@@ -0,0 +1,44 @@
+"""Schedule management commands."""
+
+import click
+
+from ..client import TrinityClient
+from ..output import format_output
+
+
+@click.group()
+def schedules():
+    """Manage agent schedules."""
+    pass
+
+
+@schedules.command("list")
+@click.argument("agent")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def list_schedules(agent, fmt):
+    """List schedules for an agent."""
+    client = TrinityClient()
+    data = client.get(f"/api/agents/{agent}/schedules")
+    if fmt == "table" and isinstance(data, list):
+        rows = [
+            {
+                "id": s.get("id", ""),
+                "skill": s.get("skill_name", ""),
+                "cron": s.get("cron_expression", ""),
+                "enabled": s.get("enabled", ""),
+            }
+            for s in data
+        ]
+        format_output(rows, fmt)
+    else:
+        format_output(data, fmt)
+
+
+@schedules.command("trigger")
+@click.argument("agent")
+@click.argument("schedule_id")
+def trigger_schedule(agent, schedule_id):
+    """Trigger a schedule immediately."""
+    client = TrinityClient()
+    data = client.post(f"/api/agents/{agent}/schedules/{schedule_id}/trigger")
+    click.echo(f"Triggered schedule {schedule_id} on '{agent}'")

trinity_cli/commands/skills.py

@@ -0,0 +1,42 @@
+"""Skills library commands."""
+
+import click
+
+from ..client import TrinityClient
+from ..output import format_output
+
+
+@click.group()
+def skills():
+    """Browse the skills library."""
+    pass
+
+
+@skills.command("list")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def list_skills(fmt):
+    """List all available skills."""
+    client = TrinityClient()
+    data = client.get("/api/skills/library")
+    if fmt == "table" and isinstance(data, list):
+        rows = [
+            {
+                "name": s.get("name", ""),
+                "description": (s.get("description", "") or "")[:60],
+                "category": s.get("category", ""),
+            }
+            for s in data
+        ]
+        format_output(rows, fmt)
+    else:
+        format_output(data, fmt)
+
+
+@skills.command("get")
+@click.argument("name")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def get_skill(name, fmt):
+    """Get details for a specific skill."""
+    client = TrinityClient()
+    data = client.get(f"/api/skills/library/{name}")
+    format_output(data, fmt)

trinity_cli/commands/tags.py

@@ -0,0 +1,31 @@
+"""Tag management commands."""
+
+import click
+
+from ..client import TrinityClient
+from ..output import format_output
+
+
+@click.group()
+def tags():
+    """Manage agent tags."""
+    pass
+
+
+@tags.command("list")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def list_tags(fmt):
+    """List all tags in use."""
+    client = TrinityClient()
+    data = client.get("/api/tags")
+    format_output(data, fmt)
+
+
+@tags.command("get")
+@click.argument("agent")
+@click.option("--format", "fmt", type=click.Choice(["json", "table"]), default="json", help="Output format")
+def get_agent_tags(agent, fmt):
+    """Get tags for a specific agent."""
+    client = TrinityClient()
+    data = client.get(f"/api/agents/{agent}/tags")
+    format_output(data, fmt)

trinity_cli/config.py

@@ -0,0 +1,193 @@
+"""Configuration management for Trinity CLI.
+
+Supports named profiles for managing multiple Trinity instances.
+Stores config in ~/.trinity/config.json with 0600 permissions.
+
+Config format:
+    {
+        "current_profile": "local",
+        "profiles": {
+            "local": {
+                "instance_url": "http://localhost:8000",
+                "token": "eyJ...",
+                "user": {"email": "admin@example.com"}
+            }
+        }
+    }
+
+Legacy flat configs are auto-migrated to a "default" profile on first access.
+"""
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+
+CONFIG_DIR = Path.home() / ".trinity"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def _ensure_config_dir():
+    CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+
+
+def _is_legacy_config(config: dict) -> bool:
+    """Check if config uses the old flat format (no profiles key)."""
+    return "profiles" not in config and ("instance_url" in config or "token" in config)
+
+
+def _migrate_legacy_config(config: dict) -> dict:
+    """Migrate flat config to profile-based format."""
+    profile_data = {}
+    for key in ("instance_url", "token", "user"):
+        if key in config:
+            profile_data[key] = config[key]
+
+    if not profile_data:
+        return {"current_profile": "default", "profiles": {}}
+
+    return {
+        "current_profile": "default",
+        "profiles": {
+            "default": profile_data,
+        },
+    }
+
+
+def load_config() -> dict:
+    """Load config, auto-migrating legacy flat format if needed."""
+    if not CONFIG_FILE.exists():
+        return {"current_profile": "default", "profiles": {}}
+    config = json.loads(CONFIG_FILE.read_text())
+    if _is_legacy_config(config):
+        config = _migrate_legacy_config(config)
+        save_config(config)
+    return config
+
+
+def save_config(config: dict):
+    _ensure_config_dir()
+    CONFIG_FILE.write_text(json.dumps(config, indent=2) + "\n")
+    os.chmod(CONFIG_FILE, stat.S_IRUSR | stat.S_IWUSR)  # 0600
+
+
+def _resolve_profile_name(explicit_profile: Optional[str] = None) -> str:
+    """Resolve which profile to use.
+
+    Priority: explicit_profile arg > TRINITY_PROFILE env var > current_profile in config.
+    """
+    if explicit_profile:
+        return explicit_profile
+    env_profile = os.environ.get("TRINITY_PROFILE")
+    if env_profile:
+        return env_profile
+    config = load_config()
+    return config.get("current_profile", "default")
+
+
+def get_profile(profile_name: Optional[str] = None) -> dict:
+    """Get the data for a specific profile (or the active one)."""
+    name = _resolve_profile_name(profile_name)
+    config = load_config()
+    return config.get("profiles", {}).get(name, {})
+
+
+def get_instance_url(profile_name: Optional[str] = None) -> Optional[str]:
+    """Get configured instance URL. Env var TRINITY_URL always wins."""
+    url = os.environ.get("TRINITY_URL")
+    if url:
+        return url.rstrip("/")
+    profile = get_profile(profile_name)
+    url = profile.get("instance_url")
+    return url.rstrip("/") if url else None
+
+
+def get_api_key(profile_name: Optional[str] = None) -> Optional[str]:
+    """Get API key/token. Env var TRINITY_API_KEY always wins."""
+    key = os.environ.get("TRINITY_API_KEY")
+    if key:
+        return key
+    profile = get_profile(profile_name)
+    return profile.get("token")
+
+
+def get_user(profile_name: Optional[str] = None) -> Optional[dict]:
+    """Get user info from the active profile."""
+    profile = get_profile(profile_name)
+    return profile.get("user")
+
+
+def set_auth(instance_url: str, token: str, user: Optional[dict] = None,
+             profile_name: Optional[str] = None):
+    """Store auth credentials in a profile."""
+    config = load_config()
+    name = _resolve_profile_name(profile_name)
+    profiles = config.setdefault("profiles", {})
+    profile = profiles.setdefault(name, {})
+    profile["instance_url"] = instance_url.rstrip("/")
+    profile["token"] = token
+    if user:
+        profile["user"] = user
+    config["current_profile"] = name
+    save_config(config)
+
+
+def clear_auth(profile_name: Optional[str] = None):
+    """Clear token and user from a profile."""
+    config = load_config()
+    name = _resolve_profile_name(profile_name)
+    profile = config.get("profiles", {}).get(name, {})
+    profile.pop("token", None)
+    profile.pop("user", None)
+    save_config(config)
+
+
+def list_profiles() -> list[dict]:
+    """List all profiles with metadata."""
+    config = load_config()
+    current = config.get("current_profile", "default")
+    profiles = config.get("profiles", {})
+    result = []
+    for name, data in profiles.items():
+        result.append({
+            "name": name,
+            "instance_url": data.get("instance_url", ""),
+            "user": (data.get("user", {}) or {}).get("email", ""),
+            "active": name == current,
+        })
+    return result
+
+
+def set_current_profile(name: str) -> bool:
+    """Switch to a different profile. Returns False if profile doesn't exist."""
+    config = load_config()
+    if name not in config.get("profiles", {}):
+        return False
+    config["current_profile"] = name
+    save_config(config)
+    return True
+
+
+def remove_profile(name: str) -> bool:
+    """Remove a profile. Returns False if it doesn't exist."""
+    config = load_config()
+    profiles = config.get("profiles", {})
+    if name not in profiles:
+        return False
+    del profiles[name]
+    # If we removed the active profile, switch to first remaining (or clear)
+    if config.get("current_profile") == name:
+        config["current_profile"] = next(iter(profiles), "default")
+    save_config(config)
+    return True
+
+
+def profile_name_from_url(url: str) -> str:
+    """Derive a profile name from an instance URL (uses hostname)."""
+    parsed = urlparse(url)
+    hostname = parsed.hostname or "default"
+    # Use just hostname, stripping port
+    return hostname

trinity_cli/main.py

@@ -0,0 +1,79 @@
+"""Trinity CLI — main entry point.
+
+Usage:
+    trinity init                    # Set up and authenticate
+    trinity login                   # Log in to an instance
+    trinity agents list             # List agents
+    trinity chat my-agent "hello"   # Chat with an agent
+    trinity logs my-agent           # View agent logs
+    trinity profile list            # Show all profiles
+    trinity profile use prod        # Switch to a profile
+"""
+
+import click
+
+from . import __version__
+from .commands.agents import agents
+from .commands.auth import init, login, logout, status
+from .commands.chat import chat_history, chat_with_agent, logs
+from .commands.health import health
+from .commands.profiles import profile
+from .commands.schedules import schedules
+from .commands.skills import skills
+from .commands.tags import tags
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="trinity")
+@click.option("--profile", "profile_name", envvar="TRINITY_PROFILE", default=None,
+              help="Profile to use (overrides TRINITY_PROFILE env var)")
+@click.pass_context
+def cli(ctx, profile_name):
+    """Trinity — Autonomous Agent Orchestration Platform CLI.
+
+    Get started:
+
+        trinity init          Configure instance and log in
+
+        trinity agents list   List your agents
+
+        trinity chat <agent> "message"   Chat with an agent
+
+    Manage multiple instances with profiles:
+
+        trinity profile list  Show configured profiles
+
+        trinity profile use <name>  Switch active profile
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["profile"] = profile_name
+
+
+# Auth commands (top-level)
+cli.add_command(init)
+cli.add_command(login)
+cli.add_command(logout)
+cli.add_command(status)
+
+# Profile management
+cli.add_command(profile)
+
+# Resource commands (groups)
+cli.add_command(agents)
+cli.add_command(health)
+cli.add_command(skills)
+cli.add_command(schedules)
+cli.add_command(tags)
+
+# Standalone commands
+cli.add_command(chat_with_agent)
+cli.add_command(chat_history, name="history")
+cli.add_command(logs)
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

trinity_cli/output.py

@@ -0,0 +1,62 @@
+"""Output formatting for Trinity CLI.
+
+JSON by default (for piping/scripting). --format table for humans.
+"""
+
+import json
+import sys
+from typing import Any
+
+import click
+
+
+def format_output(data: Any, fmt: str = "json"):
+    """Format and print data according to the chosen format."""
+    if fmt == "json":
+        click.echo(json.dumps(data, indent=2, default=str))
+    elif fmt == "table":
+        if isinstance(data, list):
+            _print_table(data)
+        elif isinstance(data, dict):
+            _print_dict(data)
+        else:
+            click.echo(str(data))
+
+
+def _print_table(rows: list[dict]):
+    """Print a list of dicts as a table."""
+    if not rows:
+        click.echo("(no results)")
+        return
+
+    # Use rich for nice tables
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console(file=sys.stdout)
+    table = Table(show_header=True, header_style="bold")
+
+    keys = list(rows[0].keys())
+    for key in keys:
+        table.add_column(key)
+
+    for row in rows:
+        table.add_row(*[str(row.get(k, "")) for k in keys])
+
+    console.print(table)
+
+
+def _print_dict(data: dict):
+    """Print a single dict as key-value pairs."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console(file=sys.stdout)
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Field")
+    table.add_column("Value")
+
+    for key, value in data.items():
+        table.add_row(str(key), str(value))
+
+    console.print(table)

trinity_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: trinity-cli
+Version: 0.1.0
+Summary: CLI for the Trinity Autonomous Agent Orchestration Platform
+Author-email: Ability AI <hello@ability.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/abilityai/trinity
+Project-URL: Documentation, https://github.com/abilityai/trinity/blob/main/docs/CLI.md
+Project-URL: Repository, https://github.com/abilityai/trinity
+Project-URL: Issues, https://github.com/abilityai/trinity/issues
+Keywords: trinity,ai,agents,orchestration,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.24
+Requires-Dist: rich>=13.0
+
+# Trinity CLI
+
+Command-line interface for the [Trinity](https://github.com/abilityai/trinity) Autonomous Agent Orchestration Platform.
+
+## Install
+
+```bash
+# With pip
+pip install trinity-cli
+
+# With pipx (recommended — isolated environment)
+pipx install trinity-cli
+```
+
+## Quick Start
+
+```bash
+# Connect to your Trinity instance
+trinity init
+
+# List your agents
+trinity agents list
+
+# Chat with an agent
+trinity chat my-agent "Hello, what can you do?"
+
+# Check fleet health
+trinity health fleet
+```
+
+## Multi-Instance Profiles
+
+Manage multiple Trinity instances (local dev, staging, production):
+
+```bash
+# First instance (created during init)
+trinity init
+
+# Add another instance
+trinity init --profile production
+
+# Switch between instances
+trinity profile use production
+trinity profile list
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `trinity init` | Connect to a Trinity instance |
+| `trinity login` | Re-authenticate with stored instance |
+| `trinity agents list` | List all agents |
+| `trinity agents create <name>` | Create a new agent |
+| `trinity agents start <name>` | Start an agent |
+| `trinity agents stop <name>` | Stop an agent |
+| `trinity chat <agent> "msg"` | Chat with an agent |
+| `trinity history <agent>` | View chat history |
+| `trinity logs <agent>` | View agent logs |
+| `trinity health fleet` | Fleet health overview |
+| `trinity health agent <name>` | Single agent health |
+| `trinity skills list` | Browse skill library |
+| `trinity schedules list <agent>` | View agent schedules |
+| `trinity profile list` | List configured profiles |
+| `trinity profile use <name>` | Switch active profile |
+
+## Output Formats
+
+```bash
+# JSON (default)
+trinity agents list
+
+# Table
+trinity agents list --format table
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `TRINITY_URL` | Override instance URL |
+| `TRINITY_API_KEY` | Override auth token |
+| `TRINITY_PROFILE` | Override active profile |
+
+## Documentation
+
+- [Full CLI docs](https://github.com/abilityai/trinity/blob/main/docs/CLI.md)
+- [Trinity Platform](https://github.com/abilityai/trinity)
+
+## License
+
+MIT

trinity_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+trinity_cli/__init__.py,sha256=v-Zb6iFOT2o-v4fgNbQ2Lz6Cu5LTOsrBddEGZOwRVUA,100
+trinity_cli/client.py,sha256=CsttCmygZ6xxDw5GUrF9RjeXTeYEWmL5eQdKE9RRc5k,4122
+trinity_cli/config.py,sha256=G7WZJiWlYlT9ujWMetm5MCZ2pIZqxpCqSe3g-CgP-Bw,5941
+trinity_cli/main.py,sha256=BIKI4kVMHUQbVH7WpSfTu0Lutf-5891I-_YBSnn2lKE,2107
+trinity_cli/output.py,sha256=E247ugQw6VMD5p7iOu9BxcuIUe0q4xByXiZdkpTFJhU,1529
+trinity_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+trinity_cli/commands/agents.py,sha256=opvgFbpLTTxurdGcgVo-ojKKA3XA0XJ_ogCwuNpY9Hg,2739
+trinity_cli/commands/auth.py,sha256=d2Uq05PPdPrh4XlNyg7IDEn5vfI0Wo5EG-g8v_Dj-Yc,6032
+trinity_cli/commands/chat.py,sha256=CCIwR4CbqKGUfY0HecAOez9Sj6mYOW-a7iIbvezTW9k,1980
+trinity_cli/commands/health.py,sha256=RaiNVGLESZfjpXhoadiKHret8wLcFIIlxIdGXaevKNQ,868
+trinity_cli/commands/profiles.py,sha256=rXvSWF9KnLP10-1fd5DdCKpDBLXHxNZWcXCwMyEmB2A,1650
+trinity_cli/commands/schedules.py,sha256=pMyp172bGsKgaPP8eyLjBndv8TmA1FWGldPUwE2mBKM,1261
+trinity_cli/commands/skills.py,sha256=lDcNtFDXaG45ecnUgzl_D95sRwbrRwfBrKJuKepgelk,1171
+trinity_cli/commands/tags.py,sha256=KBM1b_2af7cAO0D1xQHgXRkV_F-XDjJM_gP795Yn-hU,800
+trinity_cli-0.1.0.dist-info/METADATA,sha256=88XFwWQBwv6a51gbhDVWHv1lk4WCLiPdqK_NZgBVFbw,3295
+trinity_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+trinity_cli-0.1.0.dist-info/entry_points.txt,sha256=Soep8vtpg25_4TTBoU-69WQKtjBUVn2r2KQNY_kpkws,49
+trinity_cli-0.1.0.dist-info/top_level.txt,sha256=xlhMZagfk4_iC3gfgPDXnPiM5dqnBScErFvzSF02KIA,12
+trinity_cli-0.1.0.dist-info/RECORD,,

trinity_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

trinity_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trinity = trinity_cli.main:cli

trinity_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+trinity_cli