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

cli/commands/pipelines/schedules/update_command.py

@@ -0,0 +1,139 @@
+"""Pipeline schedule update command implementation."""
+
+import json
+from typing import Annotated
+from uuid import UUID
+
+import typer
+
+from alloy_runtime_types.dtos.schedule import UpdateScheduleRequest
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.update_presenter import present_update_result
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_schedules_update_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    schedule_id: str = typer.Argument(
+        ...,
+        help="Schedule UUID",
+    ),
+    name: Annotated[
+        str | None,
+        typer.Option(
+            "-n",
+            "--name",
+            help="New schedule name",
+        ),
+    ] = None,
+    description: Annotated[
+        str | None,
+        typer.Option(
+            "-d",
+            "--description",
+            help="New schedule description",
+        ),
+    ] = None,
+    input_params: Annotated[
+        str | None,
+        typer.Option(
+            "--input-params",
+            "-i",
+            help="Input parameters as JSON string",
+        ),
+    ] = None,
+    timeout: Annotated[
+        int | None,
+        typer.Option(
+            "--timeout",
+            "-t",
+            help="Execution timeout in seconds (1-3600)",
+            min=1,
+            max=3600,
+        ),
+    ] = None,
+    enable: Annotated[
+        bool | None,
+        typer.Option(
+            "--enable/--disable",
+            help="Enable or disable the schedule",
+        ),
+    ] = None,
+    allow_concurrent: Annotated[
+        bool | None,
+        typer.Option(
+            "--allow-concurrent/--no-concurrent",
+            help="Allow or disallow concurrent executions",
+        ),
+    ] = None,
+    max_failures: Annotated[
+        int | None,
+        typer.Option(
+            "--max-failures",
+            help="Auto-disable after this many consecutive failures (0 = never)",
+            min=0,
+        ),
+    ] = None,
+) -> None:
+    """Update a pipeline schedule.
+
+    Examples:
+        ai pipelines schedules update 123e4567... 456e7890... -n 'New Name'
+        ai pipelines schedules update 123e4567... 456e7890... --disable
+        ai pipelines schedules update 123e4567... 456e7890... --timeout 600
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    s_uuid = validate_uuid(schedule_id, "schedule")
+
+    params = None
+    if input_params:
+        try:
+            params = json.loads(input_params)
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON for --input-params: {e}")
+
+    # Check at least one update flag was provided
+    if all(
+        v is None
+        for v in [
+            name,
+            description,
+            input_params,
+            timeout,
+            enable,
+            allow_concurrent,
+            max_failures,
+        ]
+    ):
+        raise typer.BadParameter(
+            "At least one update flag required: --name, --description, --input-params, "
+            "--timeout, --enable/--disable, --allow-concurrent/--no-concurrent, --max-failures"
+        )
+
+    request = UpdateScheduleRequest(
+        name=name,
+        description=description,
+        input_parameters=params,
+        timeout_seconds=timeout,
+        is_enabled=enable,
+        allow_concurrent=allow_concurrent,
+        max_consecutive_failures=max_failures,
+    )
+
+    _execute_update(pipeline_id=p_uuid, schedule_id=s_uuid, request=request)
+
+
+@async_command
+async def _execute_update(
+    pipeline_id: UUID, schedule_id: UUID, request: UpdateScheduleRequest
+) -> None:
+    """Execute update schedule operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.update_pipeline_schedule(
+            pipeline_id, schedule_id, request
+        )
+
+    present_update_result(response)

cli/commands/pipelines/schedules/update_presenter.py

@@ -0,0 +1,29 @@
+"""Presenter for pipeline schedule update command output."""
+
+from alloy_runtime_types.dtos.schedule import UpdateScheduleResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def present_update_result(response: UpdateScheduleResponse) -> None:
+    """Present updated schedule details."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "Schedule ID", str),
+        FieldConfig("name", "Name"),
+        FieldConfig("is_enabled", "Enabled", lambda v: "Yes" if v else "No"),
+        FieldConfig(
+            "next_run_at",
+            "Next Run",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+        FieldConfig(
+            "updated_at",
+            "Updated",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+    ]
+
+    output.entity(response, f"Updated schedule: {response.name}", fields)

cli/commands/render/html_to_image/command.py

@@ -0,0 +1,170 @@
+"""Render HTML to image command implementation."""
+
+import base64
+from pathlib import Path
+
+import typer
+
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import get_console
+from cli.infrastructure.file_content import FileContentError, resolve_content
+from alloy_runtime_types.dtos.render import RenderHtmlToImageRequest
+
+
+def render_html_to_image_command(
+    html: str = typer.Option(
+        ...,
+        "-h",
+        "--html",
+        help="HTML text to render (or @file to read from file)",
+    ),
+    output_file: str = typer.Option(
+        ...,
+        "-o",
+        "--output",
+        help="Output file path for the PNG image",
+    ),
+    bg_color: str = typer.Option(
+        "#ffffff",
+        "--bg",
+        "--background",
+        help="Background color in hex format (default: white)",
+    ),
+    text_color: str = typer.Option(
+        "#000000",
+        "--fg",
+        "--foreground",
+        help="Text color in hex format (default: black)",
+    ),
+    font_family: str = typer.Option(
+        "Georgia, serif",
+        "--font",
+        help="CSS font-family value (used as fallback when --font-url is provided)",
+    ),
+    font_url: str | None = typer.Option(
+        None,
+        "--font-url",
+        help="Google Fonts URL (font name is auto-extracted from URL)",
+    ),
+    width: int = typer.Option(
+        1080,
+        "-W",
+        "--width",
+        min=100,
+        max=4096,
+        help="Image width in pixels (default: 1080 for social media)",
+    ),
+    height: int = typer.Option(
+        1080,
+        "-H",
+        "--height",
+        min=100,
+        max=4096,
+        help="Image height in pixels (default: 1080 for social media)",
+    ),
+) -> None:
+    """Render HTML text to a PNG image.
+
+    Creates a square 1080x1080 image by default, perfect for social media ads
+    (Instagram, Facebook). Uses white background with black text.
+
+    Examples:
+
+        # Basic usage with inline HTML
+        ai render image -h "<strong>Hello</strong> World!" -o output.png
+
+        # Read HTML from file
+        ai render image -h @content.html -o output.png
+
+        # Custom colors (dark mode)
+        ai render image -h "Dark mode" -o dark.png --bg "#1a1a1a" --fg "#ffffff"
+
+        # Custom dimensions (Instagram story: 1080x1920)
+        ai render image -h "Story" -o story.png -W 1080 -H 1920
+
+        # Custom font
+        ai render image -h "Custom" -o custom.png --font "Arial, sans-serif"
+
+        # Google Font (font name auto-extracted from URL)
+        ai render image -h "Elegant" -o elegant.png \\
+            --font-url "https://fonts.googleapis.com/css2?family=Playfair+Display:wght@700"
+    """
+    # Resolve @file references for HTML content
+    try:
+        resolved_html = resolve_content(html)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    if not resolved_html:
+        raise typer.BadParameter("HTML content cannot be empty")
+
+    # Validate hex color format
+    import re
+
+    hex_pattern = r"^#[0-9a-fA-F]{6}$"
+    if not re.match(hex_pattern, bg_color):
+        raise typer.BadParameter(
+            f"Invalid background color '{bg_color}'. Use hex format like #ffffff"
+        )
+    if not re.match(hex_pattern, text_color):
+        raise typer.BadParameter(
+            f"Invalid text color '{text_color}'. Use hex format like #000000"
+        )
+
+    _execute_render(
+        html=resolved_html,
+        output_file=output_file,
+        bg_color=bg_color,
+        text_color=text_color,
+        font_family=font_family,
+        font_url=font_url,
+        width=width,
+        height=height,
+    )
+
+
+@async_command
+async def _execute_render(
+    html: str,
+    output_file: str,
+    bg_color: str,
+    text_color: str,
+    font_family: str,
+    font_url: str | None,
+    width: int,
+    height: int,
+) -> None:
+    """Execute the render HTML to image API call."""
+    console = get_console()
+
+    async with authenticated_client() as (_config, client):
+        request = RenderHtmlToImageRequest(
+            html_text=html,
+            bg_color=bg_color,
+            text_color=text_color,
+            font_family=font_family,
+            font_url=font_url,
+            width=width,
+            height=height,
+        )
+
+        console.print(f"[dim]Rendering {width}x{height} image...[/dim]")
+        response = await client.render_html_to_image(request)
+
+    # Decode base64 and write to file
+    image_bytes = base64.b64decode(response.image_base64)
+    output_path = Path(output_file)
+
+    # Create parent directories if needed
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write the image
+    output_path.write_bytes(image_bytes)
+
+    # Report success
+    file_size_kb = len(image_bytes) / 1024
+    console.print(
+        f"[green]Image saved:[/green] {output_file} "
+        f"({response.width}x{response.height}, {file_size_kb:.1f} KB, "
+        f"{response.render_time_ms}ms)"
+    )

cli/commands/schemas/create/command.py

@@ -0,0 +1,122 @@
+"""Schema create command implementation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.flag_utils import (
+    require_one_of,
+    validate_schema_format,
+    validate_scope,
+)
+from cli.commands.schemas.create.presenter import present_schema_create_success
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.file_content import FileContentError, resolve_content
+from alloy_runtime_types.dtos.schemas import CreateSchemaRequest
+from alloy_runtime_types.enums.ownership_scope import OwnershipScope
+
+
+def schemas_create_command(
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="Schema name",
+    ),
+    schema_format: str = typer.Option(
+        ...,
+        "--schema-format",
+        help="Format: json_schema or regex",
+    ),
+    definition: Optional[str] = typer.Option(
+        None,
+        "-D",
+        "--definition",
+        help="Schema definition (or @file)",
+    ),
+    definition_file: Optional[Path] = typer.Option(
+        None,
+        "-f",
+        "--file",
+        help="Read definition from file",
+        exists=True,
+        readable=True,
+    ),
+    description: Optional[str] = typer.Option(
+        None,
+        "-d",
+        "--description",
+        help="Schema description",
+    ),
+    scope: Optional[str] = typer.Option(
+        None,
+        "--scope",
+        help="Scope: user, organization, global",
+    ),
+) -> None:
+    """Create a new schema.
+
+    Examples:
+        ai schemas create -n user-profile --schema-format json_schema -D '{"type": "object"}'
+        ai schemas create -n api-response --schema-format json_schema -f schema.json
+        ai schemas create -n email-pattern --schema-format regex -D '^[a-z]+@.*$'
+    """
+    require_one_of(("--definition", definition), ("--file", definition_file))
+
+    _execute_create_from_flags(
+        name=name,
+        schema_format=schema_format,
+        definition=definition,
+        definition_file=definition_file,
+        description=description,
+        scope=scope,
+    )
+
+
+@async_command
+async def _execute_create(request: CreateSchemaRequest) -> None:
+    """Execute the schema creation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.create_schema(request)
+
+    present_schema_create_success(response)
+
+
+def _execute_create_from_flags(
+    name: str,
+    schema_format: str,
+    definition: Optional[str],
+    definition_file: Optional[Path],
+    description: Optional[str],
+    scope: Optional[str],
+) -> None:
+    """Build and execute schema creation."""
+    try:
+        definition = resolve_content(definition)
+    except FileContentError as e:
+        raise typer.BadParameter(str(e))
+
+    format_enum = validate_schema_format(schema_format)
+
+    if definition_file:
+        schema_definition = definition_file.read_text()
+    else:
+        schema_definition = definition or ""
+
+    if not schema_definition.strip():
+        raise typer.BadParameter("Schema definition cannot be empty")
+
+    ownership_scope = OwnershipScope.USER
+    if scope:
+        ownership_scope = validate_scope(scope)
+
+    request = CreateSchemaRequest(
+        name=name,
+        schema_format=format_enum,
+        schema_definition=schema_definition,
+        description=description,
+        scope=ownership_scope,
+    )
+
+    _execute_create(request)

cli/commands/schemas/create/presenter.py

@@ -0,0 +1,53 @@
+"""Presenter for schema creation output."""
+
+from cli.infrastructure.formatting.fields import (
+    format_datetime,
+    format_optional,
+    format_uuid,
+)
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from alloy_runtime_types.dtos.schemas import CreateSchemaResponse
+
+
+def _derive_scope(response: CreateSchemaResponse) -> str:
+    """Derive scope string from organization_id and user_id fields."""
+    if response.organization_id is not None and response.user_id is None:
+        return "organization"
+    elif response.user_id is not None:
+        return "user"
+    else:
+        return "global"
+
+
+def present_schema_create_success(response: CreateSchemaResponse) -> None:
+    """Present successful schema creation.
+
+    Args:
+        response: Schema creation response from server
+    """
+    output = OutputService.get()
+    output.success("Schema created successfully")
+
+    fields = [
+        FieldConfig("id", "ID", lambda v: format_uuid(v, short=False)),
+        FieldConfig("schema_name", "Name"),
+        FieldConfig("schema_format_id", "Format"),
+        FieldConfig("version", "Version", str),
+        FieldConfig("description", "Description", format_optional),
+        FieldConfig("scope", "Scope", lambda _: _derive_scope(response)),
+        FieldConfig(
+            "organization_id",
+            "Organization ID",
+            lambda v: format_optional(v, lambda x: format_uuid(x, short=True)),
+        ),
+        FieldConfig(
+            "user_id",
+            "User ID",
+            lambda v: format_optional(v, lambda x: format_uuid(x, short=True)),
+        ),
+        FieldConfig("is_latest", "Is Latest", str),
+        FieldConfig("created_at", "Created At", format_datetime),
+    ]
+
+    output.entity(response, f"Schema: {response.schema_name}", fields)

cli/commands/schemas/delete/command.py

@@ -0,0 +1,45 @@
+"""Schemas delete command implementation."""
+
+import typer
+
+from cli.commands.schemas.delete.presenter import present_delete_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import Confirm
+
+
+def schemas_delete_command(
+    schema: str = typer.Argument(
+        ...,
+        help="Schema name or UUID",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "-y",
+        "--yes",
+        help="Skip confirmation",
+    ),
+) -> None:
+    """Delete a schema.
+
+    Permanently removes the schema and all its versions.
+    Cannot delete schemas referenced by agents or pipelines.
+
+    Examples:
+        ai schemas delete my-schema
+        ai schemas delete my-schema -y
+        ai schemas delete 123e4567-89ab-cdef-0123-456789abcdef
+    """
+    if not yes:
+        confirmed = Confirm.ask(f"[yellow]Delete schema {schema}?[/yellow]")
+        if not confirmed:
+            raise typer.Abort()
+
+    _execute_delete(schema_identifier=schema)
+
+
+@async_command
+async def _execute_delete(schema_identifier: str) -> None:
+    async with authenticated_client() as (_config, client):
+        response = await client.delete_schema(schema_identifier)
+
+    present_delete_result(response)

cli/commands/schemas/delete/presenter.py

@@ -0,0 +1,9 @@
+"""Presenter for schemas delete command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.schemas import DeleteSchemaResponse
+
+
+def present_delete_result(response: DeleteSchemaResponse) -> None:
+    output = OutputService.get()
+    output.success(f"Deleted schema: {response.deleted_schema.schema_name}")

cli/commands/schemas/get/command.py

@@ -0,0 +1,56 @@
+"""Schemas get command implementation."""
+
+import typer
+
+from cli.commands.schemas.get.presenter import present_schema_details
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def schemas_get_command(
+    schema: str = typer.Argument(
+        ...,
+        help="Schema name or UUID",
+    ),
+) -> None:
+    """Get details of a single schema.
+
+    Retrieves the full schema metadata and definition.
+    The schema can be specified by name (recommended) or UUID.
+
+    When looking up by name, returns the latest version of the schema.
+
+    Output is piping-friendly:
+    - Metadata goes to stderr (visible in terminal but not piped)
+    - Schema definition goes to stdout (for piping to other commands)
+
+    Examples:
+        # Get by name
+        ai schemas get my-schema
+        ai schemas get user-profile-schema
+
+        # Get by UUID
+        ai schemas get 019405e0-8000-7000-a000-000000000001
+
+        # Pipe schema definition to jq or file
+        ai schemas get my-schema | jq .
+        ai schemas get my-schema > schema.json
+    """
+    _execute_get(schema_identifier=schema)
+
+
+@async_command
+async def _execute_get(schema_identifier: str) -> None:
+    """Execute get schema operation.
+
+    Args:
+        schema_identifier: Schema name or UUID
+
+    Raises:
+        NotFoundError: If schema not found or user lacks access
+        AuthenticationError: If API key is invalid
+        ServerError: If server returns 5xx error
+    """
+    async with authenticated_client() as (_config, client):
+        response = await client.get_schema(schema_identifier)
+
+    present_schema_details(response)