teardrop-cli 0.1.0__py3-none-any.whl

teardrop_cli/commands/marketplace.py

@@ -0,0 +1,192 @@
+"""marketplace commands: balance, earnings, withdraw, publish."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(
+    name="marketplace",
+    help="Marketplace — balance, earnings, withdrawals, and publishing.",
+    no_args_is_help=True,
+)
+
+
+# ---------------------------------------------------------------------------
+# balance
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def balance(
+    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:
+    """Show your marketplace balance."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import print_json, print_table, spinner
+
+    async def _fetch():
+        try:
+            return await client.get_marketplace_balance()
+        finally:
+            await client.close()
+
+    client = config.get_client(base_url)
+
+    with spinner("Fetching balance…"):
+        data = asyncio.run(_fetch())
+
+    if as_json:
+        print_json(data)
+        return
+
+    rows = [[k, v] for k, v in data.items()]
+    print_table(
+        [("Field", {"style": "bold cyan"}), "Value"],
+        rows,
+        title="Marketplace Balance",
+    )
+
+
+# ---------------------------------------------------------------------------
+# earnings
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def earnings(
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Max entries to return.")] = 20,
+    cursor: Annotated[str | None, typer.Option("--cursor", help="Pagination cursor.")] = 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:
+    """List marketplace earnings."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import print_json, print_table, spinner
+
+    async def _fetch():
+        try:
+            return await client.get_earnings(limit=limit, cursor=cursor)
+        finally:
+            await client.close()
+
+    client = config.get_client(base_url)
+
+    with spinner("Fetching earnings…"):
+        data = asyncio.run(_fetch())
+
+    if as_json:
+        print_json(data)
+        return
+
+    items: list[dict] = data.get("items", data) if isinstance(data, dict) else data
+    rows = [
+        [
+            e.get("id", ""),
+            e.get("amount", ""),
+            e.get("currency", ""),
+            e.get("created_at", ""),
+            e.get("description", ""),
+        ]
+        for e in items
+    ]
+    print_table(
+        ["ID", ("Amount", {"justify": "right"}), "Currency", "Date", "Description"],
+        rows,
+        title="Earnings",
+    )
+
+
+# ---------------------------------------------------------------------------
+# withdraw
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def withdraw(
+    amount_usdc: Annotated[
+        int, typer.Option("--amount-usdc", "-a", help="Amount to withdraw in USDC (integer).")
+    ],
+    payout_address: Annotated[
+        str, typer.Option("--payout-address", help="Wallet address to send funds to.")
+    ],
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompt.")] = False,
+    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:
+    """Withdraw marketplace earnings to a wallet address."""
+    from teardrop import WithdrawRequest
+
+    from teardrop_cli import config
+    from teardrop_cli.formatting import confirm, print_json, print_success, print_table, spinner
+
+    if not yes and not confirm(f"Withdraw {amount_usdc} USDC to {payout_address}?"):
+        raise typer.Abort()
+
+    async def _fetch():
+        try:
+            return await client.withdraw(
+                WithdrawRequest(amount_usdc=amount_usdc, payout_address=payout_address)
+            )
+        finally:
+            await client.close()
+
+    client = config.get_client(base_url)
+
+    with spinner("Processing withdrawal…"):
+        result = asyncio.run(_fetch())
+
+    if as_json:
+        print_json(result)
+        return
+
+    print_success(f"Withdrawal initiated: {amount_usdc} USDC → {payout_address}")
+    if isinstance(result, dict):
+        rows = [[k, v] for k, v in result.items()]
+        print_table([("Field", {"style": "bold cyan"}), "Value"], rows, title="Withdrawal")
+
+
+# ---------------------------------------------------------------------------
+# publish
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def publish(
+    payout_address: Annotated[
+        str,
+        typer.Option(
+            "--payout-address",
+            "-p",
+            help="Wallet address to receive marketplace earnings.",
+        ),
+    ],
+    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:
+    """Set your marketplace author config (payout address)."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import print_json, print_success, print_table, spinner
+
+    async def _fetch():
+        try:
+            return await client.set_author_config(payout_address)
+        finally:
+            await client.close()
+
+    client = config.get_client(base_url)
+
+    with spinner("Updating author config…"):
+        result = asyncio.run(_fetch())
+
+    if as_json:
+        print_json(result.model_dump() if hasattr(result, "model_dump") else result)
+        return
+
+    print_success(f"Payout address set to [bold]{payout_address}[/bold].")
+    if hasattr(result, "model_dump"):
+        rows = [[k, v] for k, v in result.model_dump().items() if v is not None]
+        print_table([("Field", {"style": "bold cyan"}), "Value"], rows, title="Author Config")

teardrop_cli/commands/mcp.py

@@ -0,0 +1,202 @@
+"""mcp commands: list, add, discover, remove."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(
+    name="mcp",
+    help="MCP servers — list, add, discover tools, and remove.",
+    no_args_is_help=True,
+)
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="list")
+def list_servers(
+    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 connected MCP servers."""
+    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_mcp_servers()
+        finally:
+            await client.close()
+
+    with spinner("Fetching MCP servers…"):
+        servers = asyncio.run(_fetch())
+
+    if as_json:
+        print_json([s.model_dump() for s in servers])
+        return
+
+    if not servers:
+        data_console.print("[dim]No MCP servers configured.[/dim]")
+        return
+
+    rows = [
+        [
+            s.id,
+            s.name,
+            getattr(s, "url", ""),
+            getattr(s, "auth_type", ""),
+            str(len(getattr(s, "tools", []) or [])),
+        ]
+        for s in servers
+    ]
+    print_table(
+        ["ID", "Name", "URL", "Auth Type", "Tools"],
+        rows,
+        title="MCP Servers",
+    )
+
+
+# ---------------------------------------------------------------------------
+# add
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def add(
+    name: Annotated[str, typer.Option("--name", "-n", help="Server name.")],
+    url: Annotated[str, typer.Option("--url", "-u", help="Server URL.")],
+    auth_type: Annotated[
+        str | None,
+        typer.Option("--auth-type", help="Auth type (e.g. none, bearer, basic)."),
+    ] = None,
+    auth_token: Annotated[
+        str | None,
+        typer.Option("--auth-token", help="Auth token / secret.", hide_input=True),
+    ] = 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:
+    """Add a new MCP server."""
+    from teardrop import CreateMcpServerRequest
+
+    from teardrop_cli import config
+    from teardrop_cli.formatting import print_json, print_success, print_table, spinner
+
+    req_kwargs: dict = {"name": name, "url": url}
+    if auth_type:
+        req_kwargs["auth_type"] = auth_type
+    if auth_token:
+        req_kwargs["auth_token"] = auth_token
+
+    client = config.get_client(base_url)
+
+    async def _fetch():
+        try:
+            return await client.create_mcp_server(CreateMcpServerRequest(**req_kwargs))
+        finally:
+            await client.close()
+
+    with spinner(f"Adding MCP server [bold]{name}[/bold]…"):
+        server = asyncio.run(_fetch())
+
+    if as_json:
+        print_json(server.model_dump())
+        return
+
+    print_success(f"MCP server [bold]{server.name}[/bold] added (id: {server.id}).")
+    rows = [[k, v] for k, v in server.model_dump().items() if v is not None]
+    print_table([("Field", {"style": "bold cyan"}), "Value"], rows, title="New MCP Server")
+
+
+# ---------------------------------------------------------------------------
+# discover
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def discover(
+    server_id: Annotated[str, typer.Argument(help="MCP server ID.")],
+    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:
+    """Discover tools exposed by an MCP server."""
+    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.discover_mcp_server_tools(server_id)
+        finally:
+            await client.close()
+
+    with spinner(f"Discovering tools for [bold]{server_id}[/bold]…"):
+        result = asyncio.run(_fetch())
+
+    tools = getattr(result, "tools", []) or []
+
+    if as_json:
+        data = result.model_dump() if hasattr(result, "model_dump") else {"tools": tools}
+        print_json(data)
+        return
+
+    if not tools:
+        data_console.print("[dim]No tools discovered.[/dim]")
+        return
+
+    rows = [
+        [
+            getattr(t, "name", ""),
+            getattr(t, "description", ""),
+            str(len(getattr(t, "parameters", {}).get("properties", {})))
+            if isinstance(getattr(t, "parameters", None), dict)
+            else "—",
+        ]
+        for t in tools
+    ]
+    print_table(
+        ["Name", "Description", "Params"],
+        rows,
+        title=f"Tools on {server_id}",
+    )
+
+
+# ---------------------------------------------------------------------------
+# remove
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def remove(
+    server_id: Annotated[str, typer.Argument(help="MCP server ID to remove.")],
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompt.")] = False,
+    base_url: Annotated[str | None, typer.Option("--base-url", hidden=True)] = None,
+) -> None:
+    """Remove an MCP server."""
+    from teardrop_cli import config
+    from teardrop_cli.formatting import confirm, print_success, spinner
+
+    if not yes and not confirm(f"Remove MCP server [bold]{server_id}[/bold]?"):
+        raise typer.Abort()
+
+    client = config.get_client(base_url)
+
+    async def _fetch():
+        try:
+            await client.delete_mcp_server(server_id)
+        finally:
+            await client.close()
+
+    with spinner(f"Removing [bold]{server_id}[/bold]…"):
+        asyncio.run(_fetch())
+
+    print_success(f"MCP server [bold]{server_id}[/bold] removed.")

teardrop_cli/commands/models.py

@@ -0,0 +1,193 @@
+"""models commands: benchmarks."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(
+    name="models",
+    help="Model catalogue and benchmarks.",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def _callback() -> None:
+    """Model catalogue and benchmarks."""
+
+
+# ---------------------------------------------------------------------------
+# benchmarks
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def benchmarks(
+    org: Annotated[
+        str | None,
+        typer.Option("--org", help="Org ID for org-scoped metrics (requires auth)."),
+    ] = None,
+    no_cache: Annotated[
+        bool,
+        typer.Option("--no-cache", "--force-refresh", help="Bypass the local 10-minute cache."),
+    ] = False,
+    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:
+    """Display model catalogue with operational metrics.
+
+    Without --org: public benchmarks (no auth required).
+    With --org ORG_ID: org-scoped metrics (auth required).
+    """
+    from teardrop import AuthenticationError
+
+    from teardrop_cli import config
+    from teardrop_cli.formatting import (
+        data_console,
+        print_error,
+        print_json,
+        spinner,
+    )
+
+    client = config.get_client(base_url)
+
+    try:
+
+        async def _fetch():
+            try:
+                if org:
+                    return await client.get_org_model_benchmarks(org_id=org)
+                else:
+                    return await client.get_model_benchmarks(no_cache=no_cache)
+            finally:
+                await client.close()
+
+        label = "Fetching org model benchmarks…" if org else "Fetching model benchmarks…"
+        with spinner(label):
+            response = asyncio.run(_fetch())
+    except AuthenticationError:
+        print_error(
+            "Not authenticated.",
+            hint="Run: `teardrop auth login`",
+        )
+        raise typer.Exit(1) from None
+    except Exception as exc:
+        status = getattr(exc, "status_code", None) or getattr(exc, "status", None)
+        if status == 401:
+            print_error("Not authenticated.", hint="Run: `teardrop auth login`")
+            raise typer.Exit(1) from None
+        print_error(f"Unexpected error: {exc}")
+        raise typer.Exit(1) from None
+
+    data = response if isinstance(response, dict) else response.model_dump()
+    models_list: list[dict] = data.get("models", [])
+
+    if as_json:
+        print_json(data)
+        return
+
+    if not models_list:
+        if org:
+            data_console.print(
+                f"[dim]No benchmark data for {org}. Run some agent tasks first.[/dim]"
+            )
+        else:
+            data_console.print("[dim]No benchmark data available.[/dim]")
+        return
+
+    if org:
+        _print_org_benchmarks(models_list, org_id=org)
+    else:
+        _print_public_benchmarks(models_list)
+
+
+# ---------------------------------------------------------------------------
+# Internal renderers
+# ---------------------------------------------------------------------------
+
+
+def _print_public_benchmarks(models: list[dict]) -> None:
+    """Render the global model catalogue table."""
+    from teardrop_cli.formatting import print_table
+
+    rows = []
+    for m in models:
+        benchmarks = m.get("benchmarks") or {}
+        pricing = m.get("pricing") or {}
+        p95 = benchmarks.get("p95_latency_ms")
+        cost_in = pricing.get("tokens_in_cost_per_1k")
+        cost_out = pricing.get("tokens_out_cost_per_1k")
+        runs = benchmarks.get("total_runs_7d")
+
+        rows.append(
+            [
+                m.get("provider", "—"),
+                m.get("model", "—"),
+                m.get("display_name", "—"),
+                str(m.get("quality_tier", "—")),
+                f"{int(p95)} ms" if p95 is not None else "—",
+                f"${cost_in:.4f}/1k" if cost_in is not None else "—",
+                f"${cost_out:.4f}/1k" if cost_out is not None else "—",
+                str(runs) if runs is not None else "—",
+            ]
+        )
+
+    print_table(
+        [
+            "Provider",
+            "Model",
+            "Display Name",
+            ("Quality", {"justify": "right"}),
+            ("Latency P95", {"justify": "right"}),
+            ("Cost (in)", {"justify": "right"}),
+            ("Cost (out)", {"justify": "right"}),
+            ("Runs 7d", {"justify": "right"}),
+        ],
+        rows,
+        title="Model Catalogue",
+    )
+
+
+def _print_org_benchmarks(models: list[dict], *, org_id: str) -> None:
+    """Render the org-scoped benchmark table."""
+    from teardrop_cli.formatting import data_console, print_table
+
+    data_console.print(f"[bold]Your org's model usage (7-day aggregate) — {org_id}[/bold]")
+
+    rows = []
+    for m in models:
+        b = m.get("benchmarks") or {}
+        runs = b.get("total_runs_7d")
+        avg_cost = b.get("avg_cost_usdc_per_run")
+        total_cost = (runs * avg_cost) if (runs is not None and avg_cost is not None) else None
+        rows.append(
+            [
+                m.get("provider", "—"),
+                m.get("model", "—"),
+                str(runs) if runs is not None else "—",
+                f"{b.get('avg_latency_ms', '—')} ms"
+                if b.get("avg_latency_ms") is not None
+                else "—",
+                f"${avg_cost:.2f}" if avg_cost is not None else "—",
+                f"${total_cost:.2f}" if total_cost is not None else "—",
+                f"{b.get('avg_tokens_per_sec', '—'):.1f}"
+                if b.get("avg_tokens_per_sec") is not None
+                else "—",
+            ]
+        )
+
+    print_table(
+        [
+            "Provider",
+            "Model",
+            ("Runs", {"justify": "right"}),
+            ("Avg Latency", {"justify": "right"}),
+            ("Avg Cost/Run", {"justify": "right"}),
+            ("Total Cost", {"justify": "right"}),
+            ("Tokens/sec", {"justify": "right"}),
+        ],
+        rows,
+    )