teardrop-cli 0.1.0__py3-none-any.whl

teardrop_cli/commands/tools.py

@@ -0,0 +1,207 @@
+"""tools commands: list, test."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(
+    name="tools",
+    help="Org tools — list and test.",
+    no_args_is_help=True,
+)
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="list")
+def list_tools(
+    as_json: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+    base_url: Annotated[str | None, typer.Option("--base-url", hidden=True)] = None,
+) -> None:
+    """List org tools."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import data_console, print_json, print_table, spinner
+
+    client = config.get_client(base_url)
+
+    async def _fetch():
+        try:
+            return await client.list_tools()
+        finally:
+            await client.close()
+
+    with spinner("Fetching tools…"):
+        tools = asyncio.run(_fetch())
+
+    if as_json:
+        print_json([t.model_dump() for t in tools])
+        return
+
+    if not tools:
+        data_console.print("[dim]No tools found.[/dim]")
+        return
+
+    rows = [
+        [
+            t.id,
+            t.name,
+            (getattr(t, "description", "") or "")[:60],
+            getattr(t, "type", ""),
+        ]
+        for t in tools
+    ]
+    print_table(
+        ["ID", "Name", "Description", "Type"],
+        rows,
+        title="Org Tools",
+    )
+
+
+# ---------------------------------------------------------------------------
+# test
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="test")
+def test_tool(
+    tool_id: Annotated[str, typer.Argument(help="Tool ID to inspect.")],
+    input_json: Annotated[
+        str | None,
+        typer.Option(
+            "--input",
+            "-i",
+            help="JSON object of input parameters for a dry-run validation.",
+        ),
+    ] = None,
+    as_json: Annotated[bool, typer.Option("--json", help="Output as JSON.")] = False,
+    base_url: Annotated[str | None, typer.Option("--base-url", hidden=True)] = None,
+) -> None:
+    """Fetch a tool definition and optionally validate input against its schema."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import (
+        console,
+        data_console,
+        print_error,
+        print_json,
+        print_success,
+        print_table,
+        spinner,
+    )
+
+    client = config.get_client(base_url)
+
+    async def _fetch():
+        try:
+            return await client.get_tool(tool_id)
+        finally:
+            await client.close()
+
+    with spinner(f"Fetching tool [bold]{tool_id}[/bold]…"):
+        tool = asyncio.run(_fetch())
+
+    tool_data = tool.model_dump()
+
+    if as_json:
+        print_json(tool_data)
+        return
+
+    # Display tool metadata
+    meta_rows = [
+        [k, v] for k, v in tool_data.items() if k not in ("parameters", "schema") and v is not None
+    ]
+    print_table([("Field", {"style": "bold cyan"}), "Value"], meta_rows, title="Tool Definition")
+
+    # Display parameter schema
+    schema = tool_data.get("parameters") or tool_data.get("schema")
+    if schema and isinstance(schema, dict):
+        props = schema.get("properties", {})
+        required = set(schema.get("required", []))
+        if props:
+            param_rows = [
+                [
+                    name,
+                    "✓" if name in required else "",
+                    pdef.get("type", ""),
+                    pdef.get("description", ""),
+                ]
+                for name, pdef in props.items()
+            ]
+            print_table(
+                ["Parameter", "Required", "Type", "Description"],
+                param_rows,
+                title="Parameters",
+            )
+
+    # Optional input validation
+    if input_json:
+        try:
+            input_data = json.loads(input_json)
+        except json.JSONDecodeError as exc:
+            print_error(f"Invalid JSON input: {exc}")
+            raise typer.Exit(1) from None
+
+        errors = _validate_input(schema, input_data) if schema else []
+        if errors:
+            print_error("Input validation failed:")
+            for err in errors:
+                console.print(f"  [red]•[/red] {err}")
+            raise typer.Exit(1)
+
+        print_success("Input is valid against the tool schema.")
+        data_console.print_json(json.dumps(input_data, default=str))
+
+
+def _validate_input(schema: dict, data: dict) -> list[str]:
+    """Basic JSON Schema validation (required fields + type checks).
+
+    Returns a list of error messages; empty list means valid.
+    Does not require jsonschema — intentionally minimal.
+    """
+    errors: list[str] = []
+    required = schema.get("required", [])
+    properties = schema.get("properties", {})
+
+    for field in required:
+        if field not in data:
+            errors.append(f"Missing required field: '{field}'")
+
+    for field, value in data.items():
+        if field in properties:
+            expected_type = properties[field].get("type")
+            if expected_type and not _matches_json_type(value, expected_type):
+                errors.append(
+                    f"Field '{field}' expected type '{expected_type}', "
+                    f"got '{type(value).__name__}'"
+                )
+
+    return errors
+
+
+_JSON_TYPE_MAP = {
+    "string": str,
+    "integer": int,
+    "number": (int, float),
+    "boolean": bool,
+    "array": list,
+    "object": dict,
+    "null": type(None),
+}
+
+
+def _matches_json_type(value, json_type: str) -> bool:
+    expected = _JSON_TYPE_MAP.get(json_type)
+    if expected is None:
+        return True  # Unknown type → no error
+    # JSON Schema: integer is a subtype of number
+    if json_type == "number" and isinstance(value, bool):
+        return False
+    if json_type == "integer" and isinstance(value, bool):
+        return False
+    return isinstance(value, expected)

teardrop_cli/config.py

@@ -0,0 +1,240 @@
+"""Configuration and credential management for teardrop-cli.
+
+Credential resolution order (highest priority first):
+  1. TEARDROP_TOKEN env var (static JWT, for CI/CD)
+  2. TEARDROP_EMAIL + TEARDROP_SECRET env vars
+  3. TEARDROP_CLIENT_ID + TEARDROP_CLIENT_SECRET env vars
+  4. System keyring
+  5. Config file (~/.config/teardrop/config.toml)
+
+Config/data directories follow XDG / platformdirs conventions.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import stat
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import platformdirs
+
+# ---------------------------------------------------------------------------
+# Keyring service name
+# ---------------------------------------------------------------------------
+_KEYRING_SERVICE = "teardrop-cli"
+_KEYRING_JWT_KEY = "jwt_token"
+_KEYRING_EMAIL_KEY = "email"
+_KEYRING_SECRET_KEY = "secret"
+_KEYRING_CLIENT_ID_KEY = "client_id"
+_KEYRING_CLIENT_SECRET_KEY = "client_secret"
+
+# ---------------------------------------------------------------------------
+# Directory helpers
+# ---------------------------------------------------------------------------
+
+
+def get_config_dir() -> Path:
+    """Return the platform-appropriate config directory, creating it if needed."""
+    path = Path(platformdirs.user_config_dir("teardrop", appauthor=False))
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _config_file() -> Path:
+    return get_config_dir() / "config.toml"
+
+
+# ---------------------------------------------------------------------------
+# Config TOML helpers
+# ---------------------------------------------------------------------------
+
+
+def load_config() -> dict[str, Any]:
+    """Load config.toml; return empty dict if it doesn't exist."""
+    cfg_path = _config_file()
+    if not cfg_path.exists():
+        return {}
+    try:
+        return tomllib.loads(cfg_path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def save_config(data: dict[str, Any]) -> None:
+    """Persist *data* to config.toml with owner-only read/write permissions."""
+    import tomli_w  # lazy import — only needed on writes
+
+    cfg_path = _config_file()
+    cfg_path.write_text(tomli_w.dumps(data), encoding="utf-8")
+    # Restrict permissions on POSIX (0o600); Windows ignores this silently.
+    with contextlib.suppress(NotImplementedError):
+        cfg_path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+# ---------------------------------------------------------------------------
+# Base URL
+# ---------------------------------------------------------------------------
+
+DEFAULT_BASE_URL = "https://api.teardrop.dev"
+
+
+def get_base_url() -> str:
+    """Return the API base URL, respecting env var and config overrides."""
+    if url := os.environ.get("TEARDROP_BASE_URL"):
+        return url.rstrip("/")
+    cfg = load_config()
+    if url := cfg.get("api", {}).get("base_url"):
+        return url.rstrip("/")
+    return DEFAULT_BASE_URL
+
+
+# ---------------------------------------------------------------------------
+# Credential storage
+# ---------------------------------------------------------------------------
+
+
+def _keyring_available() -> bool:
+    try:
+        import keyring  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def store_token(token: str) -> None:
+    """Persist a JWT token (keyring first, config file fallback)."""
+    if _keyring_available():
+        import keyring
+
+        try:
+            keyring.set_password(_KEYRING_SERVICE, _KEYRING_JWT_KEY, token)
+            return
+        except Exception:
+            # Keyring write failed (e.g. Windows CredWrite 2560-byte limit).
+            # Fall through to config file.
+            pass
+
+    cfg = load_config()
+    cfg.setdefault("auth", {})["token"] = token
+    save_config(cfg)
+
+
+def store_email_credentials(email: str, secret: str) -> None:
+    """Persist email + secret (keyring first, config file fallback).
+
+    Note: the secret (password) is stored in the keyring only. The config
+    file stores the email as plain text but never the secret.
+    """
+    if _keyring_available():
+        import keyring
+
+        keyring.set_password(_KEYRING_SERVICE, _KEYRING_EMAIL_KEY, email)
+        keyring.set_password(_KEYRING_SERVICE, _KEYRING_SECRET_KEY, secret)
+    # Always store the email in the config so we can show it in whoami
+    cfg = load_config()
+    cfg.setdefault("auth", {})["method"] = "email"
+    cfg["auth"]["email"] = email
+    save_config(cfg)
+
+
+def store_client_credentials(client_id: str, client_secret: str) -> None:
+    """Persist M2M client credentials."""
+    if _keyring_available():
+        import keyring
+
+        keyring.set_password(_KEYRING_SERVICE, _KEYRING_CLIENT_ID_KEY, client_id)
+        keyring.set_password(_KEYRING_SERVICE, _KEYRING_CLIENT_SECRET_KEY, client_secret)
+
+    cfg = load_config()
+    cfg.setdefault("auth", {})["method"] = "client_credentials"
+    # Store client_id in config (not secret), mirroring email pattern
+    cfg["auth"]["client_id"] = client_id
+    save_config(cfg)
+
+
+def clear_credentials() -> None:
+    """Remove all stored credentials from keyring and config file."""
+    if _keyring_available():
+        import keyring
+
+        for key in (
+            _KEYRING_JWT_KEY,
+            _KEYRING_EMAIL_KEY,
+            _KEYRING_SECRET_KEY,
+            _KEYRING_CLIENT_ID_KEY,
+            _KEYRING_CLIENT_SECRET_KEY,
+        ):
+            with contextlib.suppress(Exception):
+                keyring.delete_password(_KEYRING_SERVICE, key)
+
+    cfg = load_config()
+    cfg.pop("auth", None)
+    save_config(cfg)
+
+
+# ---------------------------------------------------------------------------
+# Client factory
+# ---------------------------------------------------------------------------
+
+
+def get_client(base_url: str | None = None):
+    """Build and return an ``AsyncTeardropClient`` from stored credentials.
+
+    Raises ``SystemExit`` with a friendly message if no credentials are found.
+    """
+    from teardrop import AsyncTeardropClient
+
+    from teardrop_cli.formatting import print_error
+
+    url = base_url or get_base_url()
+
+    # 1. Static token env var
+    if token := os.environ.get("TEARDROP_TOKEN"):
+        return AsyncTeardropClient(url, token=token)
+
+    # 2. Email + secret env vars
+    email_env = os.environ.get("TEARDROP_EMAIL")
+    secret_env = os.environ.get("TEARDROP_SECRET")
+    if email_env and secret_env:
+        return AsyncTeardropClient(url, email=email_env, secret=secret_env)
+
+    # 3. Client credentials env vars
+    client_id_env = os.environ.get("TEARDROP_CLIENT_ID")
+    client_secret_env = os.environ.get("TEARDROP_CLIENT_SECRET")
+    if client_id_env and client_secret_env:
+        return AsyncTeardropClient(url, client_id=client_id_env, client_secret=client_secret_env)
+
+    # 4 & 5. Keyring / config file
+    if _keyring_available():
+        import keyring
+
+        # Static JWT stored after login
+        if token := keyring.get_password(_KEYRING_SERVICE, _KEYRING_JWT_KEY):
+            return AsyncTeardropClient(url, token=token)
+
+        # Email credentials
+        email = keyring.get_password(_KEYRING_SERVICE, _KEYRING_EMAIL_KEY)
+        secret = keyring.get_password(_KEYRING_SERVICE, _KEYRING_SECRET_KEY)
+        if email and secret:
+            return AsyncTeardropClient(url, email=email, secret=secret)
+
+        # Client credentials
+        cid = keyring.get_password(_KEYRING_SERVICE, _KEYRING_CLIENT_ID_KEY)
+        csecret = keyring.get_password(_KEYRING_SERVICE, _KEYRING_CLIENT_SECRET_KEY)
+        if cid and csecret:
+            return AsyncTeardropClient(url, client_id=cid, client_secret=csecret)
+
+    # Config file fallback (static token only)
+    cfg = load_config()
+    if token := cfg.get("auth", {}).get("token"):
+        return AsyncTeardropClient(url, token=token)
+
+    print_error(
+        "Not authenticated.",
+        hint="Run [bold]teardrop auth login[/bold] to sign in.",
+    )
+    raise SystemExit(1)

teardrop_cli/formatting.py

@@ -0,0 +1,243 @@
+"""Rich formatting utilities for teardrop-cli.
+
+All decorative output is sent to **stderr** so that stdout remains clean
+for piping and ``--json`` output.  Data output (tables, JSON) is written
+to stdout via a separate ``data_console``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncIterator, Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+
+if TYPE_CHECKING:
+    pass
+
+# ---------------------------------------------------------------------------
+# Consoles
+# ---------------------------------------------------------------------------
+
+# Decorative output (spinners, status, errors) → stderr
+console = Console(stderr=True, highlight=False)
+
+# Data output (tables, JSON) → stdout so it can be piped / redirected
+data_console = Console(highlight=False)
+
+# ---------------------------------------------------------------------------
+# Error helpers
+# ---------------------------------------------------------------------------
+
+
+def print_error(message: str, *, hint: str | None = None) -> None:
+    """Print a styled error to stderr."""
+    console.print(f"[bold red]Error:[/bold red] {message}")
+    if hint:
+        console.print(f"[dim]{hint}[/dim]")
+
+
+def print_success(message: str) -> None:
+    """Print a success message to stderr."""
+    console.print(f"[bold green]✓[/bold green] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning to stderr."""
+    console.print(f"[bold yellow]⚠[/bold yellow]  {message}")
+
+
+# ---------------------------------------------------------------------------
+# Spinner / status context manager
+# ---------------------------------------------------------------------------
+
+
+@contextmanager
+def spinner(message: str) -> Iterator[None]:
+    """Show a spinner on stderr while the body runs."""
+    with console.status(message):
+        yield
+
+
+# ---------------------------------------------------------------------------
+# Table helpers
+# ---------------------------------------------------------------------------
+
+
+def print_table(
+    columns: list[str | tuple[str, dict]],
+    rows: list[list[Any]],
+    *,
+    title: str | None = None,
+) -> None:
+    """Render a Rich table to stdout.
+
+    *columns* may be plain strings or ``(header, style_kwargs)`` tuples.
+    """
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    for col in columns:
+        if isinstance(col, str):
+            table.add_column(col)
+        else:
+            header, kwargs = col
+            table.add_column(header, **kwargs)
+    for row in rows:
+        table.add_row(*[str(v) if v is not None else "—" for v in row])
+    data_console.print(table)
+
+
+def print_json(data: Any) -> None:
+    """Print *data* as pretty JSON to stdout."""
+    data_console.print_json(json.dumps(data, default=str))
+
+
+def print_json_or_table(
+    data: list[dict] | dict,
+    columns: list[str | tuple[str, dict]],
+    rows: list[list[Any]],
+    *,
+    as_json: bool,
+    title: str | None = None,
+) -> None:
+    """Output as JSON (``--json``) or a Rich table."""
+    if as_json:
+        print_json(data)
+    else:
+        print_table(columns, rows, title=title)
+
+
+# ---------------------------------------------------------------------------
+# Streaming agent response renderer
+# ---------------------------------------------------------------------------
+
+# SSE event type constants (mirrors teardrop_sdk)
+_EV_TEXT = "text_msg_content"
+_EV_TOOL_START = "tool_call_start"
+_EV_TOOL_END = "tool_call_end"
+_EV_USAGE = "usage_summary"
+_EV_BILLING = "billing_settlement"
+_EV_ERROR = "error"
+_EV_DONE = "done"
+
+
+def stream_agent_response(events: AsyncIterator) -> None:  # type: ignore[type-arg]
+    """Render a streaming agent run to the terminal.
+
+    Blocks the calling thread by running the async iterator inside
+    ``asyncio.run()``.  Renders token-by-token text, tool call indicators,
+    and a usage summary at the end.
+    """
+    asyncio.run(_render_stream(events))
+
+
+async def _render_stream(events: AsyncIterator) -> None:  # type: ignore[type-arg]
+    """Async implementation of the streaming renderer."""
+    accumulated_text = ""
+    tool_depth = 0  # track nested tool calls
+
+    # We use a Live display so we can update the rendered Markdown in-place.
+    # ``auto_refresh=False`` lets us control exactly when re-renders happen.
+    live = Live(
+        Text(""),
+        console=console,
+        refresh_per_second=15,
+        auto_refresh=True,
+        transient=False,
+    )
+
+    with live:
+        async for event in events:
+            ev_type: str = getattr(event, "type", "") or ""
+            data = getattr(event, "data", None)
+
+            if ev_type == _EV_TEXT:
+                chunk = ""
+                if isinstance(data, dict):
+                    chunk = data.get("content", "")
+                elif isinstance(data, str):
+                    chunk = data
+                accumulated_text += chunk
+                live.update(Markdown(accumulated_text))
+
+            elif ev_type == _EV_TOOL_START:
+                tool_depth += 1
+                tool_name = ""
+                if isinstance(data, dict):
+                    tool_name = data.get("tool_name", data.get("name", ""))
+                indicator = f"\n\n*[Tool: {tool_name}…]*\n"
+                live.update(Markdown(accumulated_text + indicator))
+
+            elif ev_type == _EV_TOOL_END:
+                tool_depth = max(0, tool_depth - 1)
+                if tool_depth == 0:
+                    # Clear inline indicator; response text continues
+                    live.update(Markdown(accumulated_text))
+
+            elif ev_type == _EV_USAGE:
+                # Print usage summary below the response
+                if isinstance(data, dict):
+                    _print_usage_summary(data)
+
+            elif ev_type == _EV_BILLING:
+                if isinstance(data, dict):
+                    _print_billing_settlement(data)
+
+            elif ev_type == _EV_ERROR:
+                msg = ""
+                if isinstance(data, dict):
+                    msg = data.get("message", str(data))
+                elif isinstance(data, str):
+                    msg = data
+                live.stop()
+                print_error(f"Agent error: {msg}")
+                return
+
+            elif ev_type == _EV_DONE:
+                break
+
+    # Ensure a newline after streaming output
+    console.print()
+
+
+def _print_usage_summary(data: dict) -> None:
+    parts: list[str] = []
+    if "input_tokens" in data:
+        parts.append(f"Input: {data['input_tokens']} tok")
+    if "output_tokens" in data:
+        parts.append(f"Output: {data['output_tokens']} tok")
+    if "total_cost_usd" in data:
+        parts.append(f"Cost: ${data['total_cost_usd']:.4f}")
+    if parts:
+        console.print(f"[dim]{'  ·  '.join(parts)}[/dim]")
+
+
+def _print_billing_settlement(data: dict) -> None:
+    amount = data.get("amount_charged")
+    currency = data.get("currency", "credits")
+    if amount is not None:
+        console.print(f"[dim]Charged: {amount} {currency}[/dim]")
+
+
+# ---------------------------------------------------------------------------
+# Confirmation prompt
+# ---------------------------------------------------------------------------
+
+
+def confirm(message: str, *, default: bool = False) -> bool:
+    """Prompt the user for a yes/no confirmation on stderr."""
+    suffix = " [Y/n] " if default else " [y/N] "
+    try:
+        answer = console.input(f"[bold]{message}[/bold]{suffix}").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        console.print()
+        return False
+    if not answer:
+        return default
+    return answer in ("y", "yes")