obvyr-cli 1.0.0__tar.gz

obvyr_cli-1.0.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: obvyr-cli
+Version: 1.0.0
+Summary: Command-line wrapper to allow Obvyr to capture evidence from any machine.
+License: Proprietary
+Author: Wyrd Technology Ltd
+Requires-Python: >=3.12,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: boto3 (>=1.35.68,<2.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: orjson (>=3.10.15,<4.0.0)
+Requires-Dist: pydantic (>=2.10.1,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.6.1,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: tenacity (>=9.0.0,<10.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: zstandard (>=0.25.0,<0.26.0)
+Project-URL: Homepage, https://wyrd-technology.com
+Description-Content-Type: text/markdown
+
+# Obvyr CLI
+
+Command-line wrapper to run Obvyr agents locally or in CI.
+
+## Installation
+
+```bash
+    pip install obvyr-cli
+```
+
+## Usage
+
+```bash
+    obvyr-cli --help
+```
+
+## Python Support
+
+Python 3.12+
+
+## Licence
+
+Proprietary © Wyrd Technology Ltd
+

obvyr_cli-1.0.0/README_PYPI.md

@@ -0,0 +1,23 @@
+# Obvyr CLI
+
+Command-line wrapper to run Obvyr agents locally or in CI.
+
+## Installation
+
+```bash
+    pip install obvyr-cli
+```
+
+## Usage
+
+```bash
+    obvyr-cli --help
+```
+
+## Python Support
+
+Python 3.12+
+
+## Licence
+
+Proprietary © Wyrd Technology Ltd

obvyr_cli-1.0.0/pyproject.toml

@@ -0,0 +1,139 @@
+[build-system]
+requires = ["poetry-core>=1.9.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "obvyr-cli"
+version = "1.0.0"
+description = "Command-line wrapper to allow Obvyr to capture evidence from any machine."
+authors = ["Wyrd Technology Ltd"]
+license = "Proprietary"
+readme = "README_PYPI.md"
+homepage = "https://wyrd-technology.com"
+
+exclude = [
+  "README.md",
+  "docs/**",
+  "tests/**",
+  "bin/**",
+  ".mypy_cache/**",
+  ".ruff_cache/**",
+  ".pytest_cache/**",
+  "dist/**",
+]
+
+[[tool.poetry.packages]]
+from = "src"
+include = "obvyr_cli"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+python-dotenv = "^1.0.1"
+click = "^8.1.7"
+boto3 = "^1.35.68"
+pydantic = "^2.10.1"
+pydantic-settings = "^2.6.1"
+httpx = "^0.28.1"
+tenacity = "^9.0.0"
+toml = "^0.10.2"
+orjson = "^3.10.15"
+zstandard = "^0.25.0"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.13.0"
+mypy = "^1.13.0"
+pytest = "^8.3.3"
+pytest-cov = "^7.0.0"
+black = "^25.0.0"
+pyproject-fmt = "^2.5.0"
+pytest-subprocess = "^1.5.2"
+types-toml = "^0.10.8.20240310"
+poethepoet = "^0.37.0"
+
+[tool.poetry.scripts]
+obvyr = "obvyr_cli.cli:cli_run_process"
+
+[tool.black]
+line-length = 80
+
+[tool.ruff]
+line-length = 80
+indent-width = 4
+
+lint.select = ["B", "B9", "E", "F", "I", "S", "W", "PLC"]
+lint.ignore = ["E501", "S101"]
+lint.exclude = [".venv"]
+
+[tool.pytest.ini_options]
+addopts = "-lra --no-header --color=yes --durations=5 --cov -vv -m 'not e2e' --junitxml=tests/junit.xml"
+testpaths = ["tests/"]
+python_classes = ["Should*", "Test*"]
+python_functions = ["should_*", "test_*"]
+markers = ["e2e: Large end-to-end tests that require external services"]
+junit_family = "xunit2"
+junit_suite_name = "CLI Tests"
+junit_duration_report = "call"
+
+[tool.coverage.paths]
+source = ["src", "*/site-packages"]
+
+[tool.coverage.run]
+branch = true
+source = ["src"]
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+files = ["src", "tests"]
+ignore_missing_imports = true
+disallow_untyped_defs = true
+
+[tool.poe.tasks]
+# Run the tests with coverage
+test = "pytest"
+
+# Run mypy for static type checking
+typecheck = "mypy"
+
+# Format code with Black
+srcformat = "black ."
+
+# Format the pyproject.toml file
+pyprojfmt = "pyproject-fmt pyproject.toml"
+
+format = ["srcformat"]
+
+# Lint with Ruff
+lint = "ruff check ."
+
+# Lint and fix
+lintfix = "ruff check --fix ."
+
+# All: Run all checks and tests together
+all = ["lintfix", "format", "typecheck", "test"]
+
+[tool.poe.tasks.publish_test]
+cmd = """
+bash -c '
+set -euo pipefail
+rm -rf dist
+poetry build
+python -m pip install --upgrade twine
+twine check dist/*
+poetry publish -r testpypi --skip-existing
+'
+"""
+
+[tool.poe.tasks.publish_pypi]
+cmd = """
+bash -c '
+set -euo pipefail
+rm -rf dist
+poetry build
+python -m pip install --upgrade twine
+twine check dist/*
+poetry publish --skip-existing
+'
+"""

obvyr_cli-1.0.0/src/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-1.0.0/src/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)