alloy-runtime-cli 0.2.105__tar.gz → 0.2.107__tar.gz

{alloy_runtime_cli-0.2.105 → alloy_runtime_cli-0.2.107}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.105
+Version: 0.2.107
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.2.3
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.105
-Requires-Dist: alloy-runtime-types==0.2.105
+Requires-Dist: alloy-runtime-sdk==0.2.107
+Requires-Dist: alloy-runtime-types==0.2.107
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -137,10 +137,13 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.105 → alloy_runtime_cli-0.2.107}/README.md

@@ -115,10 +115,13 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.105 → alloy_runtime_cli-0.2.107}/alloy_runtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloy-runtime-cli
-Version: 0.2.105
+Version: 0.2.107
 Summary: Alloy Runtime CLI - Command-line interface for Alloy Runtime server
 Keywords: alloy,cli,python,terminal,workflow
 Classifier: Development Status :: 3 - Alpha
@@ -16,8 +16,8 @@ Requires-Dist: textual==8.2.3
 Requires-Dist: genson==1.3.0
 Requires-Dist: pyperclip==1.11.0
 Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: alloy-runtime-sdk==0.2.105
-Requires-Dist: alloy-runtime-types==0.2.105
+Requires-Dist: alloy-runtime-sdk==0.2.107
+Requires-Dist: alloy-runtime-types==0.2.107
 Requires-Dist: trogon==0.6.0
 
 # alloy-runtime-cli
@@ -137,10 +137,13 @@ Rerun a failed, timed-out, cancelled, or approval-waiting hosted execution with:
 alloy pipelines executions rerun <pipeline_id> <execution_id>
 alloy pipelines executions rerun <pipeline_id> <execution_id> --timeout 1800
 alloy pipelines executions get <pipeline_id> <execution_id>
+alloy pipelines executions get <pipeline_id> <execution_id> --watch
+alloy pipelines executions get <pipeline_id> <execution_id> --watch --timeout 600
 ```
 
-`rerun` submits a new hosted attempt asynchronously and returns the queued
-execution state immediately. Poll `get` when you want the terminal result.
+`pipelines executions get --watch` polls the aggregate pipeline live-state endpoint and renders a compact current-state view for active child generations. JSON output emits the raw live-state DTO. Regular `pipelines executions get` remains the durable detail surface for result data, stdout/stderr, failure context, and generation-step diagnostics.
+
+`rerun` submits a new hosted attempt asynchronously and returns the queued execution state immediately. Poll `get` when you want the terminal result.
 
 ## Configuration
 

{alloy_runtime_cli-0.2.105 → alloy_runtime_cli-0.2.107}/alloy_runtime_cli.egg-info/requires.txt

@@ -4,6 +4,6 @@ textual==8.2.3
 genson==1.3.0
 pyperclip==1.11.0
 prompt-toolkit==3.0.52
-alloy-runtime-sdk==0.2.105
-alloy-runtime-types==0.2.105
+alloy-runtime-sdk==0.2.107
+alloy-runtime-types==0.2.107
 trogon==0.6.0

alloy_runtime_cli-0.2.107/cli/commands/pipelines/executions/get_command.py

@@ -0,0 +1,137 @@
+"""Pipeline execution get command implementation."""
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.executions.presenter import (
+    present_execution_detail,
+    watch_pipeline_execution_live,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.output import OutputFormat, OutputService
+
+_POLL_INTERVAL_SECONDS = 3.0
+
+
+def pipelines_executions_get_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    execution_id: str = typer.Argument(
+        ...,
+        help="Execution UUID",
+    ),
+    print_logs: bool = typer.Option(
+        False,
+        "--print-logs",
+        help="Print execution logs",
+    ),
+    result_json_file: str | None = typer.Option(
+        None,
+        "--result-json-file",
+        help="Write execution result to JSON file",
+    ),
+    watch: bool = typer.Option(
+        False,
+        "--watch",
+        help="Poll compact live state until the pipeline execution reaches a terminal state",
+    ),
+    timeout: float | None = typer.Option(
+        None,
+        "--timeout",
+        help="Maximum seconds to wait when using --watch (default: wait indefinitely)",
+    ),
+) -> None:
+    """Get details of a pipeline execution.
+
+    Examples:
+        alloy pipelines executions get 123e4567... 456e7890...
+    """
+    if watch and result_json_file is not None:
+        raise typer.BadParameter("--result-json-file can only be used without --watch")
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    e_uuid = validate_uuid(execution_id, "execution")
+    _execute_get(
+        pipeline_id=p_uuid,
+        execution_id=e_uuid,
+        print_logs=print_logs,
+        result_json_file=result_json_file,
+        watch=watch,
+        timeout=timeout,
+    )
+
+
+@async_command
+async def _execute_get(
+    pipeline_id: UUID,
+    execution_id: UUID,
+    print_logs: bool,
+    result_json_file: str | None,
+    watch: bool,
+    timeout: float | None,
+) -> None:
+    """Execute get execution operation."""
+    async with authenticated_client() as (_config, client):
+        if watch:
+            output = OutputService.get()
+            if output.format == OutputFormat.JSON:
+                start_time = time.monotonic() if timeout is not None else None
+                last_response = await client.get_pipeline_execution_live_state(
+                    pipeline_id, execution_id
+                )
+                while not last_response.is_terminal and not _watch_timed_out(
+                    start_time=start_time,
+                    timeout=timeout,
+                ):
+                    await asyncio.sleep(_POLL_INTERVAL_SECONDS)
+                    last_response = await client.get_pipeline_execution_live_state(
+                        pipeline_id, execution_id
+                    )
+
+                if not last_response.is_terminal:
+                    output.progress(f"Watch timed out after {timeout:.0f}s.")
+                output.raw(last_response)
+                return
+
+            await watch_pipeline_execution_live(
+                client=client,
+                pipeline_id=pipeline_id,
+                execution_id=execution_id,
+                timeout=timeout,
+            )
+            return
+
+        response = await client.get_pipeline_execution(pipeline_id, execution_id)
+
+    if result_json_file is not None:
+        _write_result_json_file(response.execution.result_data, result_json_file)
+
+    present_execution_detail(response, print_logs=print_logs)
+
+
+def _write_result_json_file(
+    result_data: dict[str, object] | None, output_file: str
+) -> None:
+    file_path = Path(output_file).expanduser().resolve()
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(json.dumps(result_data, indent=2), encoding="utf-8")
+    OutputService.get().result(
+        action="write",
+        resource="pipeline_execution_result",
+        extra_fields={"Path": str(file_path)},
+    )
+
+
+def _watch_timed_out(start_time: float | None, timeout: float | None) -> bool:
+    if timeout is None:
+        return False
+    if start_time is None:
+        raise RuntimeError("watch timeout requires a start time")
+    return time.monotonic() - start_time >= timeout

alloy_runtime_cli-0.2.107/cli/commands/pipelines/executions/presenter.py

@@ -0,0 +1,326 @@
+"""Presenters for pipeline executions command output."""
+
+import asyncio
+import json
+import time
+from typing import Any, cast
+from uuid import UUID
+
+from pydantic import BaseModel
+from rich.live import Live
+from rich.markup import escape
+from rich.text import Text
+
+from alloy_runtime_types.dtos.executions import ExecutionLiveStateData
+from alloy_runtime_types.dtos.pipeline import (
+    GetPipelineExecutionLiveStateResponse,
+    GetPipelineExecutionResponse,
+    ListPipelineExecutionsResponse,
+    PipelineExecutionDetail,
+    PipelineExecutionLiveGenerationStep,
+    PipelineGenerationStepAttempt,
+)
+
+from cli.infrastructure.formatting.fields import format_datetime
+from cli.infrastructure.output import OutputFormat, OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+_LIVE_POLL_INTERVAL_SECONDS = 3.0
+
+
+def _format_status(status: str) -> str:
+    """Format status with color hints."""
+    return status
+
+
+def _format_duration(duration_ms: int | None) -> Any:
+    """Format duration in human-readable format."""
+    if duration_ms is None:
+        return cast(str, None)
+    if duration_ms < 1000:
+        return f"{duration_ms}ms"
+    return f"{duration_ms / 1000:.1f}s"
+
+
+def _format_optional_datetime(value: Any) -> Any:
+    if value is None:
+        return cast(str, None)
+    return format_datetime(value)
+
+
+def _format_optional_uuid(value: Any) -> Any:
+    if value is None:
+        return cast(str, None)
+    return str(value)
+
+
+def _format_json_block(value: dict[str, object] | None) -> Any:
+    if value is None:
+        return cast(str, None)
+    if isinstance(value, BaseModel):
+        value = value.model_dump(mode="json")
+    return json.dumps(value, indent=2, sort_keys=True, default=str)
+
+
+def _format_live_phase(phase: str | None) -> str:
+    return phase or "—"
+
+
+def _format_preview(text: str | None, *, limit: int = 160) -> str:
+    if not text:
+        return ""
+    return text if len(text) <= limit else text[-limit:]
+
+
+def _format_active_tools(step: PipelineExecutionLiveGenerationStep) -> str:
+    if not step.state.active_tools:
+        return ""
+    return ", ".join(tool.tool_name for tool in step.state.active_tools)
+
+
+def _format_live_preview(state: ExecutionLiveStateData) -> str:
+    preview = _format_preview(state.text_preview) or _format_preview(
+        state.reasoning_preview
+    )
+    return preview.replace("\n", " ")
+
+
+def _format_generation_step_id(step: PipelineExecutionLiveGenerationStep) -> str:
+    if step.step_id:
+        return step.step_id
+    return str(step.generation_execution_id)[:8]
+
+
+def _format_generation_attempt_id(step: PipelineGenerationStepAttempt) -> str:
+    if step.step_id:
+        return step.step_id
+    return str(step.generation_execution_id)[:8]
+
+
+def _format_generation_steps(
+    steps: list[PipelineGenerationStepAttempt],
+) -> Any:
+    if not steps:
+        return cast(str, None)
+    lines: list[str] = []
+    for step in steps:
+        parts = [
+            _format_generation_attempt_id(step),
+            str(step.generation_execution_id),
+            step.status,
+        ]
+        if step.model:
+            parts.append(step.model)
+        if step.retryable is not None:
+            parts.append(f"retryable={step.retryable}")
+        if step.provider_reached is not None:
+            parts.append(f"provider_reached={step.provider_reached}")
+        if step.error_type:
+            parts.append(f"error_type={step.error_type}")
+        lines.append(" | ".join(parts))
+    return "\n".join(lines)
+
+
+def present_executions_list(response: ListPipelineExecutionsResponse) -> None:
+    """Present list of executions with Rich table formatting."""
+    output = OutputService.get()
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="status",
+            header_label="Status",
+            formatter=_format_status,
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="total_duration_ms",
+            header_label="Duration",
+            formatter=_format_duration,
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="queued_at",
+            header_label="Queued",
+            formatter=_format_optional_datetime,
+            compact_line=2,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="external_id",
+            header_label="External ID",
+            formatter=lambda x: x if x else cast(str, None),
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=cast(list[BaseModel], response.executions),
+        title=f"Executions ({response.total})",
+        columns=columns,
+        raw_payload=response,
+    )
+
+
+def _format_tags_from_execution(execution: PipelineExecutionDetail) -> str:
+    """Format tags for display."""
+    if not execution.tags:
+        return "[]"
+    return ", ".join(t.tag_path for t in execution.tags)
+
+
+def present_execution_detail(
+    response: GetPipelineExecutionResponse, *, print_logs: bool = False
+) -> None:
+    """Present execution details with Rich formatting."""
+    output = OutputService.get()
+    execution = response.execution
+
+    fields = [
+        FieldConfig("id", "Execution ID", str),
+        FieldConfig("pipeline_definition_id", "Pipeline ID", _format_optional_uuid),
+        FieldConfig("execution_origin", "Origin"),
+        FieldConfig("status", "Status"),
+        FieldConfig("external_id", "External ID"),
+        FieldConfig("active_attempt_id", "Active Attempt", _format_optional_uuid),
+        FieldConfig("attempt_number", "Attempt"),
+        FieldConfig("epoch", "Epoch"),
+        FieldConfig("queued_at", "Queued At", format_datetime),
+        FieldConfig("started_at", "Started At", _format_optional_datetime),
+        FieldConfig("last_heartbeat_at", "Last Heartbeat", _format_optional_datetime),
+        FieldConfig("completed_at", "Completed At", _format_optional_datetime),
+        FieldConfig("total_duration_ms", "Duration", lambda v: _format_duration(v)),
+        FieldConfig("error_message", "Error"),
+        FieldConfig("tags", "Tags", lambda _: _format_tags_from_execution(execution)),
+    ]
+
+    if execution.failure_context is not None:
+        fields.append(
+            FieldConfig("failure_context", "Failure Context", _format_json_block)
+        )
+
+    if execution.generation_steps:
+        fields.append(
+            FieldConfig(
+                "generation_steps", "Generation Steps", _format_generation_steps
+            )
+        )
+
+    if execution.result_data is not None:
+        fields.append(FieldConfig("result_data", "Result Data", _format_json_block))
+
+    if print_logs and execution.execution_stdout is not None:
+        fields.append(FieldConfig("execution_stdout", "Stdout"))
+
+    if print_logs and execution.execution_stderr is not None:
+        fields.append(FieldConfig("execution_stderr", "Stderr"))
+
+    output.entity(
+        execution,
+        f"Execution: {execution.status}",
+        fields,
+        raw_payload=response,
+    )
+
+
+def present_pipeline_execution_live_state(
+    response: GetPipelineExecutionLiveStateResponse,
+) -> None:
+    output = OutputService.get()
+    if output.format == OutputFormat.JSON:
+        output.raw(response)
+        return
+    output.text(escape(_render_live_state_text(response)))
+
+
+async def watch_pipeline_execution_live(
+    *,
+    client: Any,
+    pipeline_id: UUID,
+    execution_id: UUID,
+    timeout: float | None,
+) -> None:
+    output = OutputService.get()
+    start_time = time.monotonic() if timeout is not None else None
+    response = await client.get_pipeline_execution_live_state(pipeline_id, execution_id)
+
+    with Live(
+        _to_live_state_renderable(response),
+        console=output.console,
+        auto_refresh=False,
+        refresh_per_second=4,
+        vertical_overflow="ellipsis",
+        transient=False,
+        redirect_stdout=False,
+        redirect_stderr=False,
+    ) as live:
+        live.refresh()
+        while not response.is_terminal:
+            if _watch_timed_out(start_time=start_time, timeout=timeout):
+                output.progress(f"Watch timed out after {timeout:.0f}s.")
+                return
+            await asyncio.sleep(_LIVE_POLL_INTERVAL_SECONDS)
+            response = await client.get_pipeline_execution_live_state(
+                pipeline_id, execution_id
+            )
+            live.update(_to_live_state_renderable(response), refresh=True)
+
+
+def _to_live_state_renderable(response: GetPipelineExecutionLiveStateResponse) -> Text:
+    return Text(_render_live_state_text(response))
+
+
+def _render_live_state_text(response: GetPipelineExecutionLiveStateResponse) -> str:
+    lines = [
+        (
+            f"Pipeline execution {response.pipeline_execution_id} · {response.status} "
+            f"· terminal={response.is_terminal}"
+        ),
+        (
+            f"attempt={response.attempt_number or '—'} epoch={response.epoch or '—'} "
+            f"running={response.running_generation_count} "
+            f"tools={response.active_tool_count} live={response.live_state_status}"
+        ),
+        (f"{'Step':<24} {'State':<24} Details"),
+        (f"{'-' * 24} {'-' * 24} {'-' * 48}"),
+    ]
+
+    if not response.generation_steps:
+        lines.append(
+            f"{'—':<24} {f'{response.status} / —':<24} "
+            f"model=— live={response.live_state_status}; "
+            f"activity={_format_optional_datetime(response.latest_live_state_updated_at) or '—'}; "
+            f"tools={response.active_tool_count}; no child generation live rows yet"
+        )
+        return "\n".join(lines)
+
+    for step in response.generation_steps:
+        details = (
+            f"model={step.model or '—'} live={step.live_state_status}; "
+            f"activity={_format_optional_datetime(step.last_activity_at or step.updated_at) or '—'}; "
+            f"tools={_format_active_tools(step) or '—'}; "
+            f"preview={_format_live_preview(step.state) or '—'}"
+        )
+        lines.append(
+            f"{_format_generation_step_id(step):<24} "
+            f"{f'{step.status} / {_format_live_phase(step.phase)}':<24} "
+            f"{details}"
+        )
+    return "\n".join(lines)
+
+
+def _watch_timed_out(start_time: float | None, timeout: float | None) -> bool:
+    if timeout is None:
+        return False
+    if start_time is None:
+        raise RuntimeError("watch timeout requires a start time")
+    return time.monotonic() - start_time >= timeout

{alloy_runtime_cli-0.2.105 → alloy_runtime_cli-0.2.107}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alloy-runtime-cli"
-version = "0.2.105"
+version = "0.2.107"
 description = "Alloy Runtime CLI - Command-line interface for Alloy Runtime server"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -23,8 +23,8 @@ dependencies = [
   "genson==1.3.0",
   "pyperclip==1.11.0",
   "prompt-toolkit==3.0.52",
-  "alloy-runtime-sdk==0.2.105",
-  "alloy-runtime-types==0.2.105",
+  "alloy-runtime-sdk==0.2.107",
+  "alloy-runtime-types==0.2.107",
   "trogon==0.6.0",
 ]
 

alloy_runtime_cli-0.2.105/cli/commands/pipelines/executions/get_command.py

@@ -1,77 +0,0 @@
-"""Pipeline execution get command implementation."""
-
-import json
-from pathlib import Path
-from uuid import UUID
-
-import typer
-
-from cli.commands.flag_utils import validate_uuid
-from cli.commands.pipelines.executions.presenter import present_execution_detail
-from cli.infrastructure.command import async_command, authenticated_client
-from cli.infrastructure.output import OutputService
-
-
-def pipelines_executions_get_command(
-    pipeline_id: str = typer.Argument(
-        ...,
-        help="Pipeline UUID",
-    ),
-    execution_id: str = typer.Argument(
-        ...,
-        help="Execution UUID",
-    ),
-    print_logs: bool = typer.Option(
-        False,
-        "--print-logs",
-        help="Print execution logs",
-    ),
-    result_json_file: str | None = typer.Option(
-        None,
-        "--result-json-file",
-        help="Write execution result to JSON file",
-    ),
-) -> None:
-    """Get details of a pipeline execution.
-
-    Examples:
-        alloy pipelines executions get 123e4567... 456e7890...
-    """
-    p_uuid = validate_uuid(pipeline_id, "pipeline")
-    e_uuid = validate_uuid(execution_id, "execution")
-    _execute_get(
-        pipeline_id=p_uuid,
-        execution_id=e_uuid,
-        print_logs=print_logs,
-        result_json_file=result_json_file,
-    )
-
-
-@async_command
-async def _execute_get(
-    pipeline_id: UUID,
-    execution_id: UUID,
-    print_logs: bool,
-    result_json_file: str | None,
-) -> None:
-    """Execute get execution operation."""
-    async with authenticated_client() as (_config, client):
-        response = await client.get_pipeline_execution(pipeline_id, execution_id)
-
-    if result_json_file is not None:
-        _write_result_json_file(response.execution.result_data, result_json_file)
-
-    present_execution_detail(response, print_logs=print_logs)
-
-
-def _write_result_json_file(
-    result_data: dict[str, object] | None, output_file: str
-) -> None:
-    file_path = Path(output_file).expanduser().resolve()
-    file_path.parent.mkdir(parents=True, exist_ok=True)
-    file_path.write_text(json.dumps(result_data, indent=2), encoding="utf-8")
-    OutputService.get().result(
-        action="write",
-        resource="pipeline_execution_result",
-        extra_fields={"Path": str(file_path)},
-    )