alloy-runtime-cli 0.1.0__py3-none-any.whl

cli/commands/tool_configs/update/command.py

@@ -0,0 +1,128 @@
+"""Tool config update command implementation."""
+
+import json
+from typing import Any, Optional, cast
+
+import typer
+
+from cli.commands.flag_utils import require_update_flags
+from cli.commands.tool_configs.update.presenter import (
+    present_tool_config_update_success,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.file_content import FileContentError, resolve_content
+from alloy_runtime_types.dtos.tool_configs import UpdateToolConfigRequest
+from alloy_runtime_sdk.exceptions.errors import NotFoundError
+
+
+def tool_configs_update_command(
+    identifier: str = typer.Argument(
+        ...,
+        help="Tool config UUID or slug",
+    ),
+    name: Optional[str] = typer.Option(
+        None,
+        "-n",
+        "--name",
+        help="New name (will regenerate slug)",
+    ),
+    config: Optional[str] = typer.Option(
+        None,
+        "-c",
+        "--config",
+        help="New configuration as JSON (or @file.json)",
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="New description",
+    ),
+    clear_description: bool = typer.Option(
+        False,
+        "--clear-description",
+        help="Clear the description",
+    ),
+) -> None:
+    """Update an existing tool config.
+
+    Only specified fields are updated; others are preserved.
+
+    Examples:
+        ai tool-configs update my-config -n "New Name"
+        ai tool-configs update my-config -c '{"top_k": 20}'
+        ai tool-configs update my-config -d "Updated description"
+        ai tc update my-config --clear-description
+    """
+    # Check at least one update flag provided
+    require_update_flags(
+        ("--name", name),
+        ("--config", config),
+        ("--description", description),
+        ("--clear-description", clear_description),
+    )
+
+    _execute_update(
+        identifier=identifier,
+        name=name,
+        config=config,
+        description=description,
+        clear_description=clear_description,
+    )
+
+
+@async_command
+async def _execute_update(
+    identifier: str,
+    name: Optional[str],
+    config: Optional[str],
+    description: Optional[str],
+    clear_description: bool,
+) -> None:
+    """Execute the tool config update operation."""
+    # Build update request dict
+    request_data: dict[str, Any] = {}
+
+    if name is not None:
+        request_data["name"] = name
+
+    if config is not None:
+        # Resolve @file reference for config
+        try:
+            config_content = resolve_content(config)
+        except FileContentError as e:
+            raise typer.BadParameter(str(e))
+
+        if not config_content:
+            raise typer.BadParameter("Config cannot be empty")
+
+        # Parse config as JSON
+        try:
+            config_dict_raw = json.loads(config_content)
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON in config: {e}")
+
+        if not isinstance(config_dict_raw, dict):
+            raise typer.BadParameter("Config must be a JSON object")
+
+        request_data["config"] = cast(dict[str, Any], config_dict_raw)
+
+    if description is not None:
+        request_data["description"] = description
+    elif clear_description:
+        request_data["description"] = ""
+
+    request = UpdateToolConfigRequest(**request_data)
+
+    async with authenticated_client() as (_, client):
+        try:
+            # Try to get the tool config first to verify it exists
+            await client.get_tool_config(identifier)
+        except NotFoundError:
+            raise typer.BadParameter(
+                f"Tool config '{identifier}' not found. Use 'ai tool-configs list' to see available configs."
+            )
+
+        response = await client.update_tool_config(identifier, request)
+
+    present_tool_config_update_success(response)

cli/commands/tool_configs/update/presenter.py

@@ -0,0 +1,53 @@
+"""Presenter for tool config update command output."""
+
+import json
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from cli.infrastructure.formatting.fields import (
+    format_optional,
+    format_uuid,
+)
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.tool_configs import UpdateToolConfigResponse
+
+
+def present_tool_config_update_success(response: UpdateToolConfigResponse) -> None:
+    """Present successful tool config update.
+
+    Args:
+        response: Tool config update response from server
+    """
+    output = OutputService.get()
+
+    output.success("Tool config updated successfully")
+
+    # Build a simple table for entity display
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+
+    table.add_row("ID", format_uuid(response.id, short=False))
+    table.add_row("Slug", response.slug)
+    table.add_row("Name", response.name)
+    table.add_row("Tool ID", response.tool_id)
+    table.add_row("Description", format_optional(response.description))
+
+    # Format ownership
+    if response.user_id:
+        table.add_row("Scope", "User")
+    elif response.organization_id:
+        table.add_row("Scope", "Organization")
+    else:
+        table.add_row("Scope", "Global")
+
+    panel = Panel(table, title=f"Tool Config: {response.name}", border_style="green")
+    output.console.print(panel)
+
+    # Display config as syntax-highlighted JSON
+    config_json = json.dumps(response.config, indent=2)
+    syntax = Syntax(config_json, "json", theme="monokai", word_wrap=True)
+    config_panel = Panel(syntax, title="Configuration", border_style="blue")
+    output.console.print(config_panel)

cli/commands/tools/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/tools/get/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/tools/get/command.py

@@ -0,0 +1,42 @@
+"""Tools get command implementation."""
+
+import typer
+
+from cli.commands.tools.get.presenter import present_tool_details
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tools_get_command(
+    tool_id: str = typer.Argument(
+        ...,
+        help="Tool identifier (e.g., 'rag_search', 'web_search')",
+    ),
+) -> None:
+    """Get details of a single tool.
+
+    Retrieves the full tool definition including the parameter_schema
+    which defines what configuration options the tool accepts.
+
+    Examples:
+        ai tools get rag_search
+        ai tools get web_search
+    """
+    _execute_get(tool_id=tool_id)
+
+
+@async_command
+async def _execute_get(tool_id: str) -> None:
+    """Execute get tool operation.
+
+    Args:
+        tool_id: Tool identifier string
+
+    Raises:
+        NotFoundError: If tool not found
+        AuthenticationError: If API key is invalid
+        ServerError: If server returns 5xx error
+    """
+    async with authenticated_client() as (_config, client):
+        response = await client.get_tool(tool_id)
+
+    present_tool_details(response)

cli/commands/tools/get/presenter.py

@@ -0,0 +1,45 @@
+"""Presenter for tools get command output."""
+
+import json
+
+from typing import Any
+
+from alloy_runtime_types.dtos.tools import ToolResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def _format_parameter_schema(schema: dict[str, Any] | None) -> str:
+    """Format parameter_schema as pretty-printed JSON.
+
+    Args:
+        schema: Parameter schema dict or None
+
+    Returns:
+        Formatted JSON string, or '-' if no schema
+    """
+    if not schema:
+        return "None (no configurable parameters)"
+    return json.dumps(schema, indent=2, ensure_ascii=False)
+
+
+def present_tool_details(response: ToolResponse) -> None:
+    """Present tool details including parameter schema.
+
+    Args:
+        response: ToolResponse from server
+    """
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "ID"),
+        FieldConfig("description", "Description"),
+        FieldConfig(
+            "parameter_schema",
+            "Parameter Schema",
+            _format_parameter_schema,
+        ),
+    ]
+
+    output.entity(response, f"Tool: {response.id}", fields)

cli/commands/tools/list/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/tools/list/command.py

@@ -0,0 +1,56 @@
+"""Tools list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.tools.list.presenter import present_tools_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def tools_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    limit: int = typer.Option(
+        50,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max results",
+    ),
+    offset: int = typer.Option(
+        0,
+        "--offset",
+        min=0,
+        help="Skip N results",
+    ),
+) -> None:
+    """List available tools in the registry.
+
+    Shows all tools that can be configured on agents, including
+    their identifiers and descriptions.
+
+    Examples:
+        ai tools list
+        ai tools list -s "search"
+        ai tools list -l 10 --offset 20
+    """
+    _execute_list(search=search, limit=limit, offset=offset)
+
+
+@async_command
+async def _execute_list(search: Optional[str], limit: int, offset: int) -> None:
+    """Execute list tools operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_tools(
+            search=search,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_tools_list(response)

cli/commands/tools/list/presenter.py

@@ -0,0 +1,44 @@
+"""Presenter for tools list command output."""
+
+from alloy_runtime_types.dtos.tools import ListToolsResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def present_tools_list(response: ListToolsResponse) -> None:
+    """Present list of tools with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.tools:
+        output.info("No tools found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="description",
+            header_label="Description",
+            formatter=lambda x: x[:80] + "..." if x and len(x) > 80 else (x or "-"),
+            compact_line=2,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="parameter_schema",
+            header_label="Has Parameters",
+            formatter=lambda x: "Yes" if x else "No",
+            compact_line=1,
+            compact_style="green",
+        ),
+    ]
+
+    output.table(
+        items=response.tools,  # type: ignore[arg-type]
+        title=f"Tools ({response.total})",
+        columns=columns,
+    )

cli/commands/users/create/command.py

@@ -0,0 +1,53 @@
+"""Users create command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.users.create.presenter import present_create_result
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.users import CreateUserRequest
+from alloy_runtime_types.enums.member_role import MemberRole
+
+
+def users_create_command(
+    email: str = typer.Option(
+        ...,
+        "-e",
+        "--email",
+        help="User email address",
+    ),
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="User display name",
+    ),
+    role: Optional[str] = typer.Option(
+        None,
+        "-r",
+        "--role",
+        help="User role (member, admin, owner). Defaults to member",
+    ),
+) -> None:
+    """Create a new user.
+
+    Examples:
+        ai users create --email user@example.com --name "John Doe"
+        ai users create -e admin@example.com -n "Admin User" -r admin
+    """
+    role_enum = MemberRole(role.lower()) if role else MemberRole.MEMBER
+    _execute_create(email=email, name=name, role=role_enum)
+
+
+@async_command
+async def _execute_create(
+    email: str,
+    name: str,
+    role: MemberRole,
+) -> None:
+    request = CreateUserRequest(email=email, name=name, role_id=role)
+    async with authenticated_client() as (_config, client):
+        response = await client.create_user(request)
+
+    present_create_result(response)

cli/commands/users/create/presenter.py

@@ -0,0 +1,9 @@
+"""Presenter for users create command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.users import CreateUserResponse
+
+
+def present_create_result(response: CreateUserResponse) -> None:
+    output = OutputService.get()
+    output.success(f"Created user: {response.email}")

cli/commands/whoami/command.py

@@ -0,0 +1,42 @@
+"""Whoami command implementation."""
+
+from cli.infrastructure.command import async_command
+from cli.infrastructure.config import load_config
+from cli.infrastructure.console import get_console
+from alloy_runtime_sdk.api_client.client import ApiClient
+
+
+def whoami_command() -> None:
+    """Show current authenticated user information.
+
+    Examples:
+
+        ai whoami
+    """
+    _execute_whoami()
+
+
+@async_command
+async def _execute_whoami() -> None:
+    """Execute the whoami operation."""
+    console = get_console()
+    config = load_config()
+
+    async with ApiClient(base_url=config.api_url, api_key=config.api_key) as client:
+        me = await client.get_me()
+
+    # Print user info
+    console.print(f"[cyan]Email:[/cyan] {me.email}")
+    console.print(f"[cyan]Name:[/cyan] {me.name}")
+    console.print(f"[cyan]User ID:[/cyan] {me.user_id}")
+
+    if me.organization_id:
+        console.print(
+            f"[cyan]Organization:[/cyan] {me.organization_name or me.organization_id}"
+        )
+        console.print(f"[cyan]Organization ID:[/cyan] {me.organization_id}")
+    else:
+        console.print("[dim]No organization[/dim]")
+
+    if me.is_system_admin:
+        console.print("[yellow]System Administrator[/yellow]")

cli/infrastructure/auth_storage.py

@@ -0,0 +1,71 @@
+"""CLI authentication storage for API keys and credentials.
+
+Stores API key and URL in ~/.alloy-runtime/config file for persistent authentication.
+"""
+
+import os
+from pathlib import Path
+
+
+CONFIG_DIR = Path.home() / ".alloy-runtime"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+
+def save_credentials(api_url: str, api_key: str) -> None:
+    """Save API credentials to config file.
+
+    Creates ~/.alloy-runtime/config with API URL and key.
+
+    Args:
+        api_url: API server base URL (e.g., http://localhost:8000)
+        api_key: API authentication key
+
+    Example:
+        save_credentials("http://localhost:8000", "sk_live_abc123...")
+    """
+    CONFIG_DIR.mkdir(exist_ok=True, mode=0o700)  # Secure directory permissions
+
+    with open(CONFIG_FILE, "w") as f:
+        f.write(f"ALLOY_RUNTIME_API_URL={api_url}\n")
+        f.write(f"ALLOY_RUNTIME_API_KEY={api_key}\n")
+
+    # Set secure file permissions (owner read/write only)
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def load_credentials() -> tuple[str, str] | None:
+    """Load API credentials from config file.
+
+    Returns:
+        Tuple of (api_url, api_key) if config exists, None otherwise
+
+    Example:
+        creds = load_credentials()
+        if creds:
+            api_url, api_key = creds
+    """
+    if not CONFIG_FILE.exists():
+        return None
+
+    config: dict[str, str] = {}
+    with open(CONFIG_FILE, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            config[key] = value
+
+    if "ALLOY_RUNTIME_API_URL" in config and "ALLOY_RUNTIME_API_KEY" in config:
+        return config["ALLOY_RUNTIME_API_URL"], config["ALLOY_RUNTIME_API_KEY"]
+
+    return None
+
+
+def clear_credentials() -> None:
+    """Remove stored credentials (logout).
+
+    Deletes the config file if it exists.
+    """
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

cli/infrastructure/client_factory.py

@@ -0,0 +1,36 @@
+"""Factory for creating configured ApiClient instances."""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+
+from cli.infrastructure.config import CLIConfig
+
+
+@asynccontextmanager
+async def create_client(config: CLIConfig) -> AsyncIterator[ApiClient]:
+    """Create a configured ApiClient instance.
+
+    This factory encapsulates the ApiClient creation and configuration,
+    ensuring proper async context management and resource cleanup.
+
+    Args:
+        config: Validated CLI configuration
+
+    Yields:
+        Configured ApiClient ready for API calls
+
+    Example:
+        ```python
+        config = load_config()
+        async with create_client(config) as client:
+            response = await client.update_system_credential(...)
+        ```
+    """
+    async with ApiClient(
+        base_url=config.api_url,
+        api_key=config.api_key,
+        timeout=config.timeout,
+    ) as client:
+        yield client

cli/infrastructure/command.py

@@ -0,0 +1,75 @@
+"""Command infrastructure for consistent error handling and setup."""
+
+import asyncio
+from collections.abc import AsyncGenerator, Coroutine
+from contextlib import asynccontextmanager
+from functools import wraps
+from typing import Any, Callable, ParamSpec
+
+import typer
+
+from cli.infrastructure.client_factory import create_client
+from cli.infrastructure.config import CLIConfig, load_config
+from cli.infrastructure.error_display import display_error
+from alloy_runtime_sdk.api_client.client import ApiClient
+
+P = ParamSpec("P")
+
+
+def async_command(func: Callable[P, Coroutine[Any, Any, None]]) -> Callable[P, None]:
+    """Decorator for async CLI commands with standard error handling.
+
+    Usage:
+        @async_command
+        async def my_command(arg: str) -> None:
+            async with authenticated_client() as (config, client):
+                response = await client.some_method(arg)
+
+    The decorator handles:
+    - asyncio.run() wrapper
+    - Exception catching and display_error()
+    - typer.Exit(code=1) on failure
+
+    Args:
+        func: Async command function to wrap
+
+    Returns:
+        Wrapped sync function suitable for Typer command
+    """
+
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> None:
+        try:
+            asyncio.run(func(*args, **kwargs))
+        except (BlockingIOError, BrokenPipeError):
+            # Pipe closed or blocked - exit silently
+            # This happens when piping to programs like vim that don't immediately consume stdin
+            raise typer.Exit(code=0)
+        except Exception as e:
+            display_error(e)
+            raise typer.Exit(code=1)
+
+    return wrapper
+
+
+@asynccontextmanager
+async def authenticated_client() -> AsyncGenerator[tuple[CLIConfig, ApiClient], None]:
+    """Context manager for authenticated API operations.
+
+    Usage:
+        async with authenticated_client() as (config, client):
+            response = await client.some_method()
+
+    Handles:
+    - Configuration loading (raises ConfigurationError if missing)
+    - Client lifecycle management
+
+    Yields:
+        Tuple of (CLIConfig, ApiClient) for the operation
+
+    Raises:
+        ConfigurationError: If required configuration is missing
+    """
+    config = load_config()
+    async with create_client(config) as client:
+        yield config, client