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

cli/commands/content/list/presenter.py

@@ -0,0 +1,190 @@
+"""Presenter for content list command output."""
+
+import json
+from datetime import datetime
+from typing import Any
+
+from alloy_runtime_types.dtos.content import ListContentPartsResponse
+from alloy_runtime_types.dtos.templates import TagResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_tags(tags: list[TagResponse]) -> str:
+    """Format tags for display, truncating if too many.
+
+    Args:
+        tags: List of tag responses
+
+    Returns:
+        Formatted tags string
+    """
+    if not tags:
+        return "-"
+    tag_paths = [t.tag_path for t in tags[:3]]
+    result = ", ".join(tag_paths)
+    if len(tags) > 3:
+        result += f" (+{len(tags) - 3})"
+    return result
+
+
+def _format_content_preview(
+    content_text: str | None, content_structured: dict[str, Any] | None
+) -> str:
+    """Format content preview, truncating long content.
+
+    Args:
+        content_text: Plain text content
+        content_structured: Structured JSON content
+
+    Returns:
+        Truncated content preview string
+    """
+    max_length = 150
+
+    if content_text:
+        text = content_text.replace("\n", " ").strip()
+        if len(text) > max_length:
+            return text[: max_length - 3] + "..."
+        return text
+
+    if content_structured:
+        try:
+            json_str = json.dumps(content_structured, ensure_ascii=False)
+            if len(json_str) > max_length:
+                return json_str[: max_length - 3] + "..."
+            return json_str
+        except (TypeError, ValueError):
+            return "{...}"
+
+    return "-"
+
+
+def _format_model_info(part: Any) -> str:
+    """Format model/provider information from execution metadata.
+
+    Args:
+        part: Content part item response
+
+    Returns:
+        Formatted model info string
+    """
+    if not part.execution_metadata:
+        return "-"
+
+    provider = part.execution_metadata.provider_key or ""
+    model = part.execution_metadata.provider_model_name or ""
+
+    if provider and model:
+        # Truncate model name if too long
+        if len(model) > 25:
+            model = model[:22] + "..."
+        return f"{provider}/{model}"
+    elif model:
+        return model
+    elif provider:
+        return provider
+    return "-"
+
+
+def _format_created_at(created_at: datetime | None) -> str:
+    """Format creation timestamp for display.
+
+    Args:
+        created_at: Creation timestamp
+
+    Returns:
+        Formatted date string
+    """
+    if not created_at:
+        return "-"
+    return created_at.strftime("%Y-%m-%d %H:%M")
+
+
+def present_content_list(response: ListContentPartsResponse) -> None:
+    """Present list of content parts with Rich table formatting.
+
+    Args:
+        response: List content parts response from server
+    """
+    output = OutputService.get()
+
+    if not response.content_parts:
+        output.info("No content parts found")
+        return
+
+    # Define table columns with compact layout configuration
+    # Line 1 (primary): ID, type, model, created - machine-readable data
+    # Line 2 (detail): Content preview, tags - human-readable content
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="content_type_id",
+            header_label="Type",
+            compact_line=1,
+            compact_style="magenta",
+        ),
+        ColumnConfig(
+            source_field="_model_info",
+            header_label="Model",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="created_at",
+            header_label="Created",
+            formatter=_format_created_at,
+            compact_line=1,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="_content_preview",
+            header_label="Content",
+            compact_line=2,
+            compact_style="dim",
+        ),
+        ColumnConfig(
+            source_field="tags",
+            header_label="Tags",
+            formatter=_format_tags,
+            compact_line=2,
+            compact_style="dim italic",
+        ),
+    ]
+
+    # Pre-process items to add computed fields
+    # We need to create wrapper objects with the computed fields
+    class ContentPartWrapper:
+        """Wrapper to add computed fields for table rendering."""
+
+        def __init__(self, part: Any):
+            self._part = part
+            # Copy all original fields
+            self.id = part.id
+            self.content_type_id = part.content_type_id
+            self.tags = part.tags
+            self.created_at = part.created_at
+            # Add computed fields
+            self._content_preview = _format_content_preview(
+                part.content_text, part.content_structured
+            )
+            self._model_info = _format_model_info(part)
+
+    wrapped_items = [ContentPartWrapper(part) for part in response.content_parts]
+
+    # Render table
+    output.table(
+        items=wrapped_items,  # type: ignore[arg-type]
+        title=f"Content Parts ({response.total_count})",
+        columns=columns,
+    )
+
+    # Show pagination info if there's a next page
+    if response.cursor:
+        output.status(f"Next page: ai content list --cursor '{response.cursor}'")

cli/commands/credentials/create/command.py

@@ -0,0 +1,165 @@
+"""Credentials create command implementation."""
+
+from datetime import datetime
+from typing import Any, Optional
+
+import typer
+
+from cli.commands.credentials.create.presenter import (
+    present_org_credential_create_success,
+)
+from cli.commands.flag_utils import validate_provider
+from cli.commands.shared_flags import (
+    CREDENTIAL_VALUE,
+    DESCRIPTION,
+    NAME,
+    PROVIDER,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.organization_credentials import (
+    CreateOrganizationCredentialRequest,
+)
+from alloy_runtime_types.enums.provider import Provider
+
+
+def credentials_create_command(
+    credential_type_id: str = typer.Option(
+        ...,
+        "--type",
+        help="Credential type: org_provider or org_tool",
+    ),
+    name: str = NAME,
+    plaintext_value: str = CREDENTIAL_VALUE,
+    provider: Optional[str] = PROVIDER,
+    tool_id: Optional[str] = typer.Option(
+        None,
+        "--tool-id",
+        help="Tool identifier (mutually exclusive with -p)",
+    ),
+    description: Optional[str] = DESCRIPTION,
+    expires_at: Optional[str] = typer.Option(
+        None,
+        "--expires-at",
+        help="Expiration ISO 8601 (2025-12-31T23:59:59Z)",
+    ),
+    configuration: Optional[str] = typer.Option(
+        None,
+        "--configuration",
+        help="Type-specific config as JSON",
+    ),
+) -> None:
+    """Create an organization credential (BYOK).
+
+    Requires organization owner or admin role.
+
+    SECURITY: Use env var to avoid shell history exposure:
+        ai credentials create --value "$OPENAI_API_KEY" ...
+
+    Examples:
+
+        # Provider credential
+        ai credentials create --type org_provider -n "OpenAI" --value "sk-..." -p openai
+
+        # Tool credential
+        ai credentials create --type org_tool -n "Search" --value "key" --tool-id web_search
+    """
+    _execute_create(
+        credential_type_id=credential_type_id,
+        name=name,
+        plaintext_value=plaintext_value,
+        provider=provider,
+        tool_id=tool_id,
+        description=description,
+        expires_at=expires_at,
+        configuration=configuration,
+    )
+
+
+@async_command
+async def _execute_create(
+    credential_type_id: str,
+    name: str,
+    plaintext_value: str,
+    provider: Optional[str],
+    tool_id: Optional[str],
+    description: Optional[str],
+    expires_at: Optional[str],
+    configuration: Optional[str],
+) -> None:
+    """Execute the credential creation operation.
+
+    Args:
+        credential_type_id: Credential type ID
+        name: Friendly name
+        plaintext_value: API key value
+        provider: Optional provider key string
+        tool_id: Optional tool identifier
+        description: Optional description
+        expires_at: Optional expiration datetime (ISO 8601 string)
+        configuration: Optional configuration JSON string
+
+    Raises:
+        typer.BadParameter: If validation fails (provider, tool_id, XOR, datetime, JSON)
+        ConfigurationError: If environment variables are missing
+        AuthenticationError: If API key is invalid
+        ForbiddenError: User lacks permission (not owner/admin)
+        ValidationError: If request data is invalid
+        ConflictError: If duplicate credential exists
+        ServerError: If server returns 5xx error
+    """
+    # Validate XOR constraint: exactly one of provider or tool_id (or neither for generic)
+    has_provider = provider is not None
+    has_tool_id = tool_id is not None
+
+    if has_provider and has_tool_id:
+        raise typer.BadParameter(
+            "Cannot provide both --provider and --tool-id. Choose one or neither."
+        )
+
+    # Validate and convert provider string to enum if provided
+    provider_enum: Optional[Provider] = None
+    if provider:
+        provider_enum = validate_provider(provider)
+
+    # Parse expires_at if provided
+    expires_datetime: Optional[datetime] = None
+    if expires_at:
+        try:
+            expires_datetime = datetime.fromisoformat(expires_at.replace("Z", "+00:00"))
+        except ValueError:
+            raise typer.BadParameter(
+                f"Invalid datetime format: '{expires_at}'. Must be ISO 8601 format (e.g., '2025-12-31T23:59:59Z')"
+            )
+
+    # Parse configuration JSON if provided
+    configuration_dict: Optional[dict[str, Any]] = None
+    if configuration:
+        import json
+
+        try:
+            configuration_dict = json.loads(configuration)
+            if not isinstance(configuration_dict, dict):
+                raise typer.BadParameter(
+                    f"Configuration must be a JSON object, got {type(configuration_dict).__name__}"
+                )
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON in --configuration: {e}")
+
+    # Build request
+    request = CreateOrganizationCredentialRequest(
+        credential_type_id=credential_type_id,
+        name=name,
+        plaintext_value=plaintext_value,
+        provider_key=provider_enum,
+        tool_id=tool_id,
+        description=description,
+        expires_at=expires_datetime,
+        configuration=configuration_dict,
+    )
+
+    # Execute API call with authenticated client
+    async with authenticated_client() as (_config, client):
+        response = await client.create_organization_credential(request)
+
+    # Present success output
+    present_org_credential_create_success(response)

cli/commands/credentials/create/fields.py

@@ -0,0 +1,38 @@
+"""Field definitions for organization credential presentation."""
+
+from typing import Any, cast
+
+from cli.infrastructure.formatting.fields import format_datetime
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def format_optional_datetime(value: Any) -> str:
+    """Format optional datetime value."""
+    return format_datetime(value) if value else "(not set)"
+
+
+def format_optional_provider(value: Any) -> str:
+    """Format optional provider value."""
+    return value.value if value else "(not set)"
+
+
+def format_optional_string(value: Any) -> str:
+    """Format optional string value."""
+    return cast(str, value) if value else "(not set)"
+
+
+ORG_CREDENTIAL_FIELDS: list[FieldConfig] = [
+    FieldConfig("id", "ID", lambda v: str(v)),
+    FieldConfig("name", "Name"),
+    FieldConfig("description", "Description", format_optional_string),
+    FieldConfig("credential_type_id", "Credential Type"),
+    FieldConfig("provider_key", "Provider", format_optional_provider),
+    FieldConfig("tool_id", "Tool ID", format_optional_string),
+    FieldConfig("value_prefix", "Value Prefix", format_optional_string),
+    FieldConfig("organization_id", "Organization ID", lambda v: str(v)),
+    FieldConfig("is_active", "Is Active", lambda v: "Yes" if v else "No"),
+    FieldConfig("created_at", "Created", format_datetime),
+    FieldConfig("updated_at", "Updated", format_datetime),
+    FieldConfig("last_used_at", "Last Used", format_optional_datetime),
+    FieldConfig("expires_at", "Expires", format_optional_datetime),
+]

cli/commands/credentials/create/presenter.py

@@ -0,0 +1,20 @@
+"""Presenter for credentials create command output."""
+
+from cli.commands.credentials.create.fields import ORG_CREDENTIAL_FIELDS
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.organization_credentials import (
+    OrganizationCredentialResponse,
+)
+
+
+def present_org_credential_create_success(
+    credential: OrganizationCredentialResponse,
+) -> None:
+    """Present a successful organization credential creation with Rich formatting.
+
+    Args:
+        credential: Created organization credential data from server
+    """
+    output = OutputService.get()
+    output.success(f"Created organization credential: {credential.name}")
+    output.entity(credential, "Organization Credential Details", ORG_CREDENTIAL_FIELDS)

cli/commands/credentials/update/command.py

@@ -0,0 +1,53 @@
+"""Credential update command implementation."""
+
+from typing import Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.credentials.update.presenter import present_credential_update_success
+from cli.commands.shared_flags import (
+    CREDENTIAL_VALUE_OPTIONAL,
+    DESCRIPTION,
+    NAME_OPTIONAL,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from alloy_runtime_types.dtos.credentials import UpdateCredentialRequest
+
+
+def credentials_update_command(
+    credential_id: UUID = typer.Argument(..., help="Credential UUID"),
+    name: Optional[str] = NAME_OPTIONAL,
+    description: Optional[str] = DESCRIPTION,
+    value: Optional[str] = CREDENTIAL_VALUE_OPTIONAL,
+) -> None:
+    """Update a credential (system or organization).
+
+    At least one flag required.
+
+    Examples:
+
+        ai credentials update <uuid> -n "Production Key"
+        ai credentials update <uuid> -d "Updated" --value "sk_new"
+    """
+    _execute_update(credential_id, name, description, value)
+
+
+@async_command
+async def _execute_update(
+    credential_id: UUID,
+    name: Optional[str],
+    description: Optional[str],
+    value: Optional[str],
+) -> None:
+    """Execute the credential update operation."""
+    request = UpdateCredentialRequest(
+        name=name,
+        description=description,
+        plain_text_api_key=value,
+    )
+
+    async with authenticated_client() as (_config, client):
+        response = await client.update_credential(credential_id, request)
+
+    present_credential_update_success(response)

cli/commands/credentials/update/fields.py

@@ -0,0 +1,71 @@
+"""Field definitions for credential presentation."""
+
+from typing import Any
+
+from cli.infrastructure.formatting.fields import (
+    format_boolean,
+    format_cost,
+    format_datetime,
+)
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def format_optional_datetime(value: Any) -> str:
+    """Format optional datetime value."""
+    return format_datetime(value) if value else "(not set)"
+
+
+def format_optional_limit(value: Any) -> str:
+    """Format optional limit value."""
+    return str(value) if value is not None else "(not set)"
+
+
+def format_optional_provider(value: Any) -> str:
+    """Format optional provider enum value."""
+    return value.value if value is not None else "(not set)"
+
+
+def format_optional_boolean(value: Any) -> str:
+    """Format optional boolean value."""
+    return format_boolean(value) if value is not None else "(not set)"
+
+
+def format_optional_cost(value: Any) -> str:
+    """Format optional cost value."""
+    return format_cost(value) if value is not None else "(not set)"
+
+
+CREDENTIAL_FIELDS: list[FieldConfig] = [
+    FieldConfig("id", "ID", lambda v: str(v)),
+    FieldConfig("name", "Name"),
+    FieldConfig("description", "Description"),
+    FieldConfig("credential_type_id", "Credential Type"),
+    FieldConfig("provider_key", "Provider", format_optional_provider),
+    FieldConfig("is_active", "Is Active", format_boolean),
+    FieldConfig("value_prefix", "Value Prefix"),
+    # Organization credential field
+    FieldConfig(
+        "organization_id", "Organization ID", lambda v: str(v) if v else "(system)"
+    ),
+    # System credential fields (optional)
+    FieldConfig("priority", "Priority", format_optional_limit),
+    FieldConfig("is_default", "Is Default", format_optional_boolean),
+    FieldConfig("daily_request_limit", "Daily Request Limit", format_optional_limit),
+    FieldConfig(
+        "requests_per_minute_limit", "Requests/Minute Limit", format_optional_limit
+    ),
+    FieldConfig(
+        "monthly_cost_limit_usd", "Monthly Cost Limit (USD)", format_optional_cost
+    ),
+    FieldConfig(
+        "current_daily_requests", "Current Daily Requests", format_optional_limit
+    ),
+    FieldConfig(
+        "current_monthly_cost_usd", "Current Monthly Cost (USD)", format_optional_cost
+    ),
+    # Timestamps
+    FieldConfig("created_at", "Created", format_datetime),
+    FieldConfig("updated_at", "Updated", format_datetime),
+    FieldConfig("last_used_at", "Last Used", format_optional_datetime),
+    FieldConfig("expires_at", "Expires", format_optional_datetime),
+]

cli/commands/credentials/update/presenter.py

@@ -0,0 +1,16 @@
+"""Presenter for credential update command output."""
+
+from cli.commands.credentials.update.fields import CREDENTIAL_FIELDS
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.credentials import CredentialResponse
+
+
+def present_credential_update_success(credential: CredentialResponse) -> None:
+    """Present a successful credential update with Rich formatting.
+
+    Args:
+        credential: Updated credential data from server
+    """
+    output = OutputService.get()
+    output.success(f"Updated credential: {credential.name}")
+    output.entity(credential, "Credential Details", CREDENTIAL_FIELDS)