obvyr-cli 1.0.0__py3-none-any.whl

obvyr_cli/api_client.py

@@ -0,0 +1,134 @@
+import atexit
+import pathlib
+from typing import Any, BinaryIO, Dict, Optional, Tuple
+
+import httpx
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_fixed,
+)
+
+from obvyr_cli import utils
+from obvyr_cli.error_handling import handle_api_error, handle_network_error
+from obvyr_cli.logging_config import get_logger
+
+logger = get_logger("api_client")
+
+project_config = utils.get_project_config()
+
+
+class ObvyrAPIClient:
+    """Client for sending execution data to the Obvyr API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        timeout: float = 5.0,
+        verify_ssl: bool = True,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        """Initialize API client with optional settings injection."""
+        self.api_key = api_key
+        self.verify_ssl = verify_ssl
+        self.client: httpx.Client = http_client or httpx.Client(
+            base_url=base_url, timeout=timeout, verify=self.verify_ssl
+        )
+        self._closed = False
+        atexit.register(self.close)
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Generate headers for authentication."""
+        return {
+            "Authorization": (f"Bearer {self.api_key}"),
+            "User-Agent": f"obvyr-cli/{project_config['version']}",
+        }
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_fixed(2),
+        retry=retry_if_exception_type(
+            (httpx.RequestError, httpx.HTTPStatusError)
+        ),
+        reraise=True,
+    )
+    def send_data(
+        self,
+        endpoint: str,
+        data: Dict[str, Any],
+        file: Optional[Tuple[str, BinaryIO]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Send execution data to the API with retries on transient failures."""
+        headers = self._get_headers()
+
+        try:
+            optional_parameters: Dict[str, Any] = {}
+
+            if file:
+                optional_parameters = {
+                    **optional_parameters,
+                    "files": {"attachment": (file[0], file[1])},
+                }
+
+            response = self.client.post(
+                endpoint, headers=headers, data=data, **optional_parameters
+            )
+
+            response.raise_for_status()
+
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            return handle_api_error(e)
+        except (httpx.RequestError, httpx.TimeoutException) as e:
+            handle_network_error(e)
+            return None
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_fixed(2),
+        retry=retry_if_exception_type(
+            (httpx.RequestError, httpx.HTTPStatusError)
+        ),
+        reraise=True,
+    )
+    def send_archive(
+        self, endpoint: str, archive_path: pathlib.Path
+    ) -> Optional[Dict[str, Any]]:
+        """Send archive file to the API with retries on transient failures."""
+        if not archive_path.exists():
+            raise FileNotFoundError(f"Archive file not found: {archive_path}")
+
+        headers = self._get_headers()
+
+        try:
+            with open(archive_path, "rb") as archive_file:
+                files = {"archive": ("artifacts.tar.zst", archive_file)}
+                response = self.client.post(
+                    endpoint, headers=headers, files=files
+                )
+
+            response.raise_for_status()
+
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            return handle_api_error(e)
+        except (httpx.RequestError, httpx.TimeoutException) as e:
+            handle_network_error(e)
+            return None
+
+    def close(self) -> None:
+        """Close the HTTP connection pool."""
+        if not self._closed:
+            self.client.close()
+            self._closed = True
+            logger.debug("Closed API client connection.")
+
+    def __enter__(self) -> "ObvyrAPIClient":
+        """Enable use of `with ObvyrAPIClient() as client`."""
+        return self
+
+    def __exit__(self, *args: object, **kwargs: object) -> None:
+        """Ensure the HTTP client is closed when exiting context."""
+        self.close()

obvyr_cli/archive_builder.py

@@ -0,0 +1,147 @@
+"""
+Archive builder for creating artifacts.tar.zst files.
+
+This module creates compressed tar archives containing command execution data
+and optional attachments in the format required by the /collect API endpoint.
+"""
+
+import io
+import json
+import os
+import pathlib
+import tarfile
+import tempfile
+from datetime import UTC, datetime
+from typing import Dict, Optional
+
+import zstandard as zstd
+from pydantic import BaseModel
+
+from obvyr_cli.schemas import RunCommandResponse
+
+
+class ArchiveSummary(BaseModel):
+    """Summary of archive contents and sizes."""
+
+    archive_bytes: int
+    members: Dict[str, Dict[str, int]]
+
+
+def build_artifacts_tar_zst(
+    run_command_response: RunCommandResponse,
+    attachment_paths: Optional[list[pathlib.Path]] = None,
+    tmp_dir: Optional[pathlib.Path] = None,
+    tags: Optional[list[str]] = None,
+) -> pathlib.Path:
+    """
+    Build artifacts.tar.zst archive from command execution data.
+
+    Creates a compressed tar archive containing:
+    - /command.json (required)
+    - /output.txt (optional; UTF-8 mixed stdout/stderr)
+    - /attachment/<filename> (optional)
+
+    Args:
+        run_command_response: Command execution response containing metadata and output
+        attachment_paths: Optional list of attachment files to include
+        tmp_dir: Optional temporary directory for output file
+        tags: Optional list of tags to include in command.json
+
+    Returns:
+        Path to the created artifacts.tar.zst file
+    """
+    if tmp_dir is None:
+        tmp_dir = pathlib.Path(tempfile.gettempdir())
+
+    # Create output file path
+    output_path = tmp_dir / "artifacts.tar.zst"
+
+    # Prepare command.json data exactly as specified in the doc
+    command_data = {
+        "command": run_command_response.command,
+        "user": run_command_response.user,
+        "return_code": run_command_response.returncode,
+        "execution_time_ms": round(run_command_response.execution_time * 1000),
+        "executed": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+        "env": dict(os.environ),
+        "tags": tags or [],
+    }
+
+    # Create tar archive in memory first
+    tar_buffer = io.BytesIO()
+
+    with tarfile.open(fileobj=tar_buffer, mode="w") as tar:
+        # Add command.json (required)
+        command_json_bytes = json.dumps(
+            command_data, separators=(",", ":")
+        ).encode("utf-8")
+        command_info = tarfile.TarInfo("command.json")
+        command_info.size = len(command_json_bytes)
+        tar.addfile(command_info, io.BytesIO(command_json_bytes))
+
+        # Add output.txt if present (optional; mixed stdout/stderr)
+        if run_command_response.output:
+            output_bytes = run_command_response.output.encode("utf-8")
+            output_info = tarfile.TarInfo("output.txt")
+            output_info.size = len(output_bytes)
+            tar.addfile(output_info, io.BytesIO(output_bytes))
+
+        # Add attachments if provided (optional)
+        if attachment_paths:
+            for attachment_path in attachment_paths:
+                if not attachment_path.exists():
+                    continue
+
+                # Use attachment/<filename> structure as specified
+                arcname = f"attachment/{attachment_path.name}"
+
+                # Stream file without loading into memory
+                with open(attachment_path, "rb") as f:
+                    attachment_info = tarfile.TarInfo(arcname)
+                    attachment_info.size = attachment_path.stat().st_size
+                    tar.addfile(attachment_info, f)
+
+    # Compress tar with zstd
+    tar_buffer.seek(0)
+    tar_data = tar_buffer.read()
+
+    compressor = zstd.ZstdCompressor(write_content_size=True)
+    compressed_data = compressor.compress(tar_data)
+
+    with open(output_path, "wb") as output_file:
+        output_file.write(compressed_data)
+
+    return output_path
+
+
+def summarize_archive(archive_path: pathlib.Path) -> ArchiveSummary:
+    """
+    Summarise contents of an artifacts.tar.zst archive.
+
+    Args:
+        archive_path: Path to the artifacts.tar.zst file
+
+    Returns:
+        ArchiveSummary containing archive size and member information
+
+    Raises:
+        FileNotFoundError: If archive file doesn't exist
+    """
+    if not archive_path.exists():
+        raise FileNotFoundError(f"Archive not found: {archive_path}")
+
+    # Get archive size
+    archive_bytes = archive_path.stat().st_size
+
+    # Extract and examine tar contents
+    decompressor = zstd.ZstdDecompressor()
+    members: Dict[str, Dict[str, int]] = {}
+
+    with open(archive_path, "rb") as archive_file:
+        with decompressor.stream_reader(archive_file) as reader:
+            with tarfile.open(fileobj=reader, mode="r|") as tar:
+                for member in tar:
+                    if member.isfile():
+                        members[member.name] = {"bytes": member.size}
+
+    return ArchiveSummary(archive_bytes=archive_bytes, members=members)

obvyr_cli/cli.py

@@ -0,0 +1,352 @@
+import pathlib
+import time
+from typing import List
+
+import click
+
+from obvyr_cli.api_client import ObvyrAPIClient
+from obvyr_cli.archive_builder import build_artifacts_tar_zst
+from obvyr_cli.command_wrapper import run_command
+from obvyr_cli.config import AgentSettings, Settings, get_settings
+from obvyr_cli.error_handling import handle_archive_error
+from obvyr_cli.logging_config import configure_logging, get_logger
+from obvyr_cli.schemas import (
+    CommandExecutionConfig,
+    OutputMode,
+    RunCommandResponse,
+)
+
+logger = get_logger("cli")
+
+# ===================================
+# CLI Support Functions
+# ===================================
+
+
+def _resolve_output_mode(
+    output_mode: str, no_stream: bool, force_stream: bool
+) -> OutputMode:
+    """
+    Resolve output mode from CLI flags with priority handling.
+
+    Args:
+        output_mode: Base output mode from --output-mode flag.
+        no_stream: Whether --no-stream flag was used.
+        force_stream: Whether --force-stream flag was used.
+
+    Returns:
+        Resolved OutputMode.
+
+    Raises:
+        click.UsageError: If conflicting flags are provided.
+    """
+    # Check for conflicting flags
+    if no_stream and force_stream:
+        raise click.UsageError(
+            "Cannot use both --no-stream and --force-stream flags together."
+        )
+
+    # Priority: specific flags override --output-mode
+    if no_stream:
+        return OutputMode.BATCH
+    if force_stream:
+        return OutputMode.STREAM
+
+    # Use specified output mode
+    return OutputMode(output_mode.lower())
+
+
+def is_attachment_fresh(
+    attachment_path: pathlib.Path, max_age_seconds: int = 10
+) -> bool:
+    """
+    Check if an attachment file is fresh enough to be included.
+
+    Args:
+        attachment_path: Path to the attachment file
+        max_age_seconds: Maximum age in seconds for file to be considered fresh
+
+    Returns:
+        True if file exists and was modified within max_age_seconds, False otherwise
+    """
+    if not attachment_path.exists():
+        return False
+
+    if max_age_seconds <= 0:
+        return False
+
+    current_time = time.time()
+    file_mtime = attachment_path.stat().st_mtime
+    file_age_seconds = current_time - file_mtime
+
+    return file_age_seconds < max_age_seconds
+
+
+def list_available_agents(settings: Settings) -> None:
+    """
+    Lists all available agents.
+    """
+    agents = settings.list_agents()
+
+    if len(agents) == 0:
+        click.echo("\nNo agents available.\n")
+        return
+
+    click.echo("\nAvailable agents:\n")
+    for agent in agents:
+        click.echo(f"  - {agent}")
+    click.echo("")
+
+
+def show_agent_config(
+    settings: Settings, agent_name: str | None = None
+) -> None:
+    """
+    Shows the configuration for the specified or active agent.
+    """
+    config = settings.show_config(agent_name)
+
+    agent_display = agent_name or "DEFAULT"
+    click.echo(f"\nAgent '{agent_display}' configuration:\n")
+    for key, value in config.items():
+        click.echo(f"  {key}: {value}")
+    click.echo("")
+
+
+def has_handled_initial_options(
+    command: List[str],
+    list_agents: bool,
+    show_config: bool,
+    settings: Settings,
+    agent: str | None = None,
+) -> bool:
+    """Handle initial options for listing agents or showing configuration."""
+    if command:
+        return False
+
+    if list_agents:
+        list_available_agents(settings)
+        return True
+
+    if show_config:
+        show_agent_config(settings, agent)
+        return True
+
+    raise click.UsageError(
+        "\n".join(
+            (
+                "No command provided.",
+                "Usage: obvyr-cli <command> [arguments]",
+                "Try 'obvyr-cli --help' for more information.",
+            )
+        )
+    )
+
+
+def fetch_active_agent(
+    settings: Settings, agent_name: str | None = None
+) -> AgentSettings:
+    """Retrieve the active agent from settings."""
+    active_agent = settings.get_agent(agent_name)
+    agent_display_name = agent_name or "DEFAULT"
+    logger.debug(f"Using agent: {agent_display_name}")
+    return active_agent
+
+
+def display_execution_summary(response: RunCommandResponse) -> None:
+    """Display the execution summary after streaming output."""
+    output = (
+        f"\nExecuted by {click.style(response.user, fg='green')} "
+        f"in {click.style(f'{response.execution_time:.2f}s', fg='blue')}\n"
+    )
+    click.echo(output)
+
+
+def display_output(response: RunCommandResponse) -> None:
+    """Display the command's output (legacy function for backward compatibility)."""
+    if response.output:
+        click.echo(f"\n{response.output}")
+    display_execution_summary(response)
+
+
+def send_to_api(active_agent: AgentSettings, data: RunCommandResponse) -> None:
+    """
+    Sends execution data to the Obvyr API.
+
+    :param active_agent: Agent configuration to use for API submission.
+    :param data: Command execution result to be sent to the API.
+    """
+
+    if not active_agent.API_KEY:
+        logger.debug("API submission disabled: No API key configured.")
+        return
+
+    archive_path = None
+    try:
+        # Create archive from command execution data
+        attachment_paths = None
+        if active_agent.ATTACHMENT_PATH:
+            attachment_path = pathlib.Path(active_agent.ATTACHMENT_PATH)
+            # Only include attachment if it's fresh
+            if is_attachment_fresh(
+                attachment_path, active_agent.ATTACHMENT_MAX_AGE_SECONDS
+            ):
+                attachment_paths = [attachment_path]
+                logger.debug(f"Including fresh attachment: {attachment_path}")
+            else:
+                logger.debug(f"Skipping stale attachment: {attachment_path}")
+
+        # Build archive with or without attachments
+        archive_path = build_artifacts_tar_zst(
+            data, attachment_paths=attachment_paths, tags=active_agent.TAGS
+        )
+
+        with ObvyrAPIClient(
+            api_key=active_agent.API_KEY,
+            base_url=active_agent.API_URL,
+            timeout=active_agent.TIMEOUT,
+            verify_ssl=active_agent.VERIFY_SSL,
+        ) as client:
+            start_time = time.time()
+            response = client.send_archive("/collect", archive_path)
+            end_time = time.time()
+
+            logger.debug(f"API request time: {end_time - start_time:.2f}s")
+
+            if response:
+                logger.debug(f"Successfully sent data to API: {response}")
+            else:
+                logger.warning(
+                    "Failed to send data to API. Check your configuration."
+                )
+
+    except OSError as e:
+        handle_archive_error(e)
+    except Exception as e:
+        # Other errors are already handled by the API client's centralised error handling
+        logger.error(f"Unexpected error during API submission: {e}")
+    finally:
+        # Always clean up the temporary archive file
+        if archive_path and archive_path.exists():
+            archive_path.unlink()
+
+
+# ===================================
+# Click CLI
+# ===================================
+
+
+@click.command(context_settings={"ignore_unknown_options": True})
+@click.argument("command", nargs=-1, required=False, type=click.UNPROCESSED)
+@click.option(
+    "--list-agents",
+    "list_agents",
+    is_flag=True,
+    help="List all available agents.",
+)
+@click.option(
+    "--show-config",
+    "show_config",
+    is_flag=True,
+    help="Show config for active agent.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose logging (debug mode).",
+)
+@click.option(
+    "--quiet",
+    "-q",
+    is_flag=True,
+    help="Enable quiet mode (errors only).",
+)
+@click.option(
+    "--agent",
+    "-a",
+    help="Specify which agent configuration to use.",
+)
+@click.option(
+    "--output-mode",
+    type=click.Choice(["auto", "stream", "batch"], case_sensitive=False),
+    default="auto",
+    help="Output mode: auto (CI detection), stream (force streaming), batch (force batch).",
+)
+@click.option(
+    "--no-stream",
+    is_flag=True,
+    help="Disable streaming output (equivalent to --output-mode=batch).",
+)
+@click.option(
+    "--force-stream",
+    is_flag=True,
+    help="Force streaming output (equivalent to --output-mode=stream).",
+)
+@click.option(
+    "--no-color",
+    is_flag=True,
+    help="Disable color output (don't set FORCE_COLOR environment variable).",
+)
+def cli_run_process(
+    command: List[str],
+    list_agents: bool,
+    show_config: bool,
+    verbose: bool,
+    quiet: bool,
+    agent: str | None,
+    output_mode: str,
+    no_stream: bool,
+    force_stream: bool,
+    no_color: bool,
+) -> None:
+    """
+    Executes a system command while using the Obvyr agent configuration.
+    """
+    # Configure logging based on CLI flags
+    configure_logging(verbose=verbose, quiet=quiet)
+
+    # Resolve output mode from flags
+    resolved_output_mode = _resolve_output_mode(
+        output_mode, no_stream, force_stream
+    )
+
+    # Create command execution configuration
+    # force_color=True by default, --no-color flag disables it
+    execution_config = CommandExecutionConfig(
+        output_mode=resolved_output_mode,
+        force_color=not no_color,  # Default True, disabled by --no-color flag
+        preserve_ansi=True,
+    )
+
+    try:
+        settings = get_settings()
+
+        if has_handled_initial_options(
+            command, list_agents, show_config, settings, agent
+        ):
+            return
+
+        active_agent = fetch_active_agent(settings, agent)
+
+        # Create streaming callback for real-time output display
+        def stream_output(line: str) -> None:
+            """Stream output line-by-line to console."""
+            click.echo(line)
+
+        response: RunCommandResponse = run_command(
+            list(command),
+            stream_callback=stream_output,
+            config=execution_config,
+        )
+
+        if active_agent.API_URL and active_agent.API_KEY:
+            send_to_api(active_agent, response)
+
+        display_execution_summary(response)
+
+        if response.returncode != 0:
+            raise click.exceptions.Exit(response.returncode)
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e