brava-attack-simulation 0.1.0__tar.gz

brava_attack_simulation-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    name: Lint and type check
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Lint
+        run: uv run ruff check src/
+
+      - name: Format check
+        run: uv run ruff format --check src/
+
+      - name: Type check
+        run: uv run pyright src/

brava_attack_simulation-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

brava_attack_simulation-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+.venv/
+.env
+.ruff_cache/
+*.code-workspace

brava_attack_simulation-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

brava_attack_simulation-0.1.0/AGENTS.md

@@ -0,0 +1,75 @@
+# Attack Simulation CLI
+
+CLI frontend for the attack simulation manager REST API. Wraps the manager's HTTP endpoints in an argparse-based command interface.
+
+- **Language:** Python 3.14+, Hatchling build
+- **HTTP client:** httpx
+- **Entry point:** `src/simulation_cli/__main__.py`
+- **Installed command:** `simulation-cli`
+
+## Build & Run
+
+```bash
+uv sync                    # install deps
+uv run simulation-cli --help
+
+# Auth via flags
+uv run simulation-cli --url http://localhost:3000 --token <JWT> catalog list
+
+# Auth via env / .env file
+export MANAGER_URL=http://localhost:3000
+export MANAGER_API_TOKEN=<JWT>
+uv run simulation-cli catalog list
+```
+
+## Lint & Typecheck
+
+```bash
+uv run ruff check src/     # lint
+uv run ruff format src/    # format
+uv run pyright src/        # strict mode
+```
+
+Pyright is configured as `strict` in `pyproject.toml`. All code must pass with zero errors.
+
+## Architecture
+
+```
+src/simulation_cli/
+  __main__.py              # argparse entry point, dispatch
+  client.py                # ManagerClient — thin httpx wrapper over manager REST API
+  types.py                 # Snapshot type alias (TODO: replace with brava package models)
+  commands/
+    catalog.py             # catalog list/get — browse simulation metadata
+    run.py                 # run simulation create/list/get, run goal create/list/get
+  reporting/
+    protocol.py            # IResultPrinter — output format protocol
+    json_printer.py        # JsonPrinter — indented JSON to stdout
+```
+
+### Command structure
+
+```
+simulation-cli catalog list [--search X] [--offset N] [--limit N]
+simulation-cli catalog get <id>
+simulation-cli run simulation create --simulation-id SIM1 --account-id UUID --region us-east-1 [--params '{}']
+simulation-cli run simulation list [--account-id UUID] [--offset N] [--limit N]
+simulation-cli run simulation get <id>
+simulation-cli run goal create --goal "text" --account-id UUID --region us-east-1 [--profile-identifier ARN]
+simulation-cli run goal list [--account-id UUID] [--offset N] [--limit N]
+simulation-cli run goal get <id>
+```
+
+### Key patterns
+
+- **Printing is behind a protocol.** `IResultPrinter` in `reporting/protocol.py` defines the output contract. `JsonPrinter` is the current implementation. New formats (table, YAML, etc.) implement the same protocol.
+- **`Snapshot` is a temporary type alias** (`dict[str, Any] | list[Any]`). It will be replaced by typed Pydantic models from `brava-attack-simulation-manager` once the manager CI generates and publishes them.
+- **Client methods never raise on HTTP errors.** They call `sys.exit()` with a message. Command modules don't need try/except around client calls.
+- **`--params` accepts a JSON string**, parsed and validated in `commands/run.py` before forwarding to the client.
+
+## Conventions
+
+- Follow the coding principles in the [root AGENTS.md](../AGENTS.md) — sad-path defaults, minimal nesting, focused helpers.
+- New commands go in `commands/` — each module exports `register(subparsers)` and `execute(args, client, printer)`.
+- All client methods return `Snapshot` and live in `client.py` grouped by manager resource.
+- Use `jj` for version control (colocated jj+git repo).

brava_attack_simulation-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

brava_attack_simulation-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: brava-attack-simulation
+Version: 0.1.0
+Summary: Brava Security CLI for attack simulations and security testing
+Requires-Python: >=3.14
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0

brava_attack_simulation-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "brava-attack-simulation"
+version = "0.1.0"
+description = "Brava Security CLI for attack simulations and security testing"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "httpx>=0.28.0",
+    "python-dotenv>=1.0.0",
+    "typer>=0.15.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+brava = "simulation_cli.app:app"
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.408",
+    "ruff>=0.15.9",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pyright]
+typeCheckingMode = "strict"
+pythonVersion = "3.14"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/simulation_cli"]

brava_attack_simulation-0.1.0/src/simulation_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for ``python -m simulation_cli``."""
+
+from simulation_cli.app import app
+
+if __name__ == "__main__":
+    app()

brava_attack_simulation-0.1.0/src/simulation_cli/app.py

@@ -0,0 +1,437 @@
+"""Brava CLI — enterprise attack simulation management."""
+
+import os
+import sys
+from typing import Annotated, Optional
+
+import typer
+from dotenv import load_dotenv
+
+from simulation_cli import auth
+from simulation_cli.client import BravaClient
+from simulation_cli.context import CliContext
+
+load_dotenv()
+
+app = typer.Typer(
+    name="brava",
+    help="Brava Security — attack simulation CLI",
+    no_args_is_help=True,
+)
+
+auth_app = typer.Typer(help="Manage authentication credentials")
+catalog_app = typer.Typer(help="Browse the simulation catalog")
+run_app = typer.Typer(help="Manage simulation and goal runs")
+sim_app = typer.Typer(help="Simulation run commands")
+goal_app = typer.Typer(help="Describe-goal run commands")
+doctor_app = typer.Typer(help="Check CLI prerequisites")
+
+app.add_typer(auth_app, name="auth")
+app.add_typer(catalog_app, name="catalog")
+app.add_typer(run_app, name="run")
+app.add_typer(doctor_app, name="doctor")
+run_app.add_typer(sim_app, name="simulation")
+run_app.add_typer(goal_app, name="goal")
+
+
+def _resolve_context(json_mode: bool = False) -> CliContext:
+    """Resolve URL and token from args, env, or stored credentials."""
+    url = os.environ.get("BRAVA_URL")
+    token = os.environ.get("BRAVA_API_TOKEN")
+
+    if not url or not token:
+        stored = auth.load_credentials()
+        if stored:
+            token = token or stored.token
+            url = url or stored.url
+
+    if not url:
+        typer.echo(
+            "Error: No Brava URL configured. Run `brava auth login` or set BRAVA_URL.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    if not token:
+        typer.echo(
+            "Error: Not authenticated. Run `brava auth login --token <PAT>` or set BRAVA_API_TOKEN.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    client = BravaClient(url=url, token=token)
+    return CliContext(client=client, json_mode=json_mode)
+
+
+# ---------------------------------------------------------------------------
+# auth commands
+# ---------------------------------------------------------------------------
+
+
+@auth_app.command("login")
+def auth_login(
+    token: Annotated[
+        str, typer.Option("--token", "-t", help="Personal access token (PAT)")
+    ],
+    url: Annotated[
+        str, typer.Option("--url", help="Brava platform URL")
+    ] = "https://console.brava.security",
+) -> None:
+    """Store credentials for the Brava platform."""
+    auth.store_credentials(token, url)
+    typer.echo(f"Credentials saved. Platform URL: {url}")
+
+
+@auth_app.command("logout")
+def auth_logout() -> None:
+    """Remove stored credentials."""
+    auth.clear_credentials()
+    typer.echo("Credentials removed.")
+
+
+@auth_app.command("status")
+def auth_status() -> None:
+    """Show current authentication status."""
+    env_token = os.environ.get("BRAVA_API_TOKEN")
+    stored = auth.load_credentials()
+
+    if env_token:
+        typer.echo(
+            f"Authenticated via BRAVA_API_TOKEN env var (prefix: {env_token[:12]}...)"
+        )
+    elif stored:
+        token, url = stored
+        typer.echo(f"Authenticated via stored credentials (prefix: {token[:12]}...)")
+        typer.echo(f"  Platform URL: {url}")
+    else:
+        typer.echo(
+            "Not authenticated. Run `brava auth login --token <PAT>` or set BRAVA_API_TOKEN."
+        )
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# catalog commands
+# ---------------------------------------------------------------------------
+
+
+@catalog_app.command("list")
+def catalog_list(
+    search: Annotated[
+        Optional[str], typer.Option(help="Filter by name/description")
+    ] = None,
+    limit: Annotated[Optional[int], typer.Option(help="Max results")] = None,
+    offset: Annotated[Optional[int], typer.Option(help="Skip N results")] = None,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """List available simulations from the catalog."""
+    ctx = _resolve_context(json)
+    result = ctx.client.list_simulations(search=search, limit=limit, offset=offset)
+    ctx.print(result)
+
+
+@catalog_app.command("get")
+def catalog_get(
+    id: Annotated[str, typer.Argument(help="Simulation ID (e.g. SIM1)")],
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Get simulation details by ID."""
+    ctx = _resolve_context(json)
+    result = ctx.client.get_simulation(id)
+    ctx.print(result)
+
+
+# ---------------------------------------------------------------------------
+# run simulation commands
+# ---------------------------------------------------------------------------
+
+
+@sim_app.command("create")
+def sim_create(
+    simulation_id: Annotated[
+        str, typer.Option("--simulation-id", help="Simulation ID (e.g. SIM1)")
+    ],
+    account_id: Annotated[
+        str, typer.Option("--account-id", help="Brava environment UUID")
+    ],
+    region: Annotated[str, typer.Option("--region", help="Target AWS region")],
+    params: Annotated[
+        Optional[str], typer.Option(help="Runtime params as JSON string")
+    ] = None,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Create a new simulation run."""
+    import json as json_mod
+
+    parsed_params = None
+    if params:
+        try:
+            parsed_params = json_mod.loads(params)
+        except json_mod.JSONDecodeError as exc:
+            typer.echo(f"Error: Invalid --params JSON: {exc}", err=True)
+            raise typer.Exit(1)
+
+    ctx = _resolve_context(json)
+    result = ctx.client.create_run(
+        simulation_id=simulation_id,
+        account_id=account_id,
+        region=region,
+        params=parsed_params,
+    )
+    ctx.print(result)
+
+
+@sim_app.command("list")
+def sim_list(
+    account_id: Annotated[
+        Optional[str], typer.Option("--account-id", help="Filter by environment")
+    ] = None,
+    limit: Annotated[Optional[int], typer.Option(help="Max results")] = None,
+    offset: Annotated[Optional[int], typer.Option(help="Skip N results")] = None,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """List simulation runs."""
+    ctx = _resolve_context(json)
+    result = ctx.client.list_runs(account_id=account_id, limit=limit, offset=offset)
+    ctx.print(result)
+
+
+@sim_app.command("get")
+def sim_get(
+    id: Annotated[str, typer.Argument(help="Simulation run UUID")],
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Get simulation run details."""
+    ctx = _resolve_context(json)
+    result = ctx.client.get_run(id)
+    ctx.print(result)
+
+
+@sim_app.command("watch")
+def sim_watch(
+    id: Annotated[str, typer.Argument(help="Simulation run UUID")],
+    interval: Annotated[int, typer.Option(help="Poll interval in seconds")] = 5,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Watch a simulation run until completion."""
+    import time
+    from rich.live import Live
+    from rich.text import Text
+
+    ctx = _resolve_context(json)
+    terminal_statuses = {
+        "COMPLETED",
+        "FAILED",
+        "TIMED_OUT",
+        "completed",
+        "failed",
+        "timed_out",
+    }
+
+    if ctx.json_mode:
+        while True:
+            data = ctx.client.get_run(id)
+            status = data.get("status", "") if isinstance(data, dict) else ""
+            ctx.print(data)
+            if status in terminal_statuses:
+                raise typer.Exit(0 if status.lower() == "completed" else 1)
+            time.sleep(interval)
+    else:
+        with Live(Text("Polling..."), refresh_per_second=1) as live:
+            while True:
+                data = ctx.client.get_run(id)
+                status = data.get("status", "") if isinstance(data, dict) else ""
+                live.update(ctx.format(data))
+                if status in terminal_statuses:
+                    ctx.print(data)
+                    raise typer.Exit(0 if status.lower() == "completed" else 1)
+                time.sleep(interval)
+
+
+# ---------------------------------------------------------------------------
+# run goal commands
+# ---------------------------------------------------------------------------
+
+
+@goal_app.command("create")
+def goal_create(
+    goal: Annotated[str, typer.Option("--goal", help="Free-text research goal")],
+    account_id: Annotated[
+        str, typer.Option("--account-id", help="Brava environment UUID")
+    ],
+    region: Annotated[str, typer.Option("--region", help="Target AWS region")],
+    profile_identifier: Annotated[
+        Optional[str], typer.Option("--profile", help="Profile identifier (role ARN)")
+    ] = None,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Create a new describe-goal run."""
+    ctx = _resolve_context(json)
+    result = ctx.client.create_goal_run(
+        goal=goal,
+        account_id=account_id,
+        region=region,
+        profile_identifier=profile_identifier,
+    )
+    ctx.print(result)
+
+
+@goal_app.command("list")
+def goal_list(
+    account_id: Annotated[
+        Optional[str], typer.Option("--account-id", help="Filter by environment")
+    ] = None,
+    limit: Annotated[Optional[int], typer.Option(help="Max results")] = None,
+    offset: Annotated[Optional[int], typer.Option(help="Skip N results")] = None,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """List describe-goal runs."""
+    ctx = _resolve_context(json)
+    result = ctx.client.list_goal_runs(
+        account_id=account_id, limit=limit, offset=offset
+    )
+    ctx.print(result)
+
+
+@goal_app.command("get")
+def goal_get(
+    id: Annotated[str, typer.Argument(help="Describe-goal run UUID")],
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Get describe-goal run details."""
+    ctx = _resolve_context(json)
+    result = ctx.client.get_goal_run(id)
+    ctx.print(result)
+
+
+@goal_app.command("watch")
+def goal_watch(
+    id: Annotated[str, typer.Argument(help="Describe-goal run UUID")],
+    interval: Annotated[int, typer.Option(help="Poll interval in seconds")] = 5,
+    json: Annotated[bool, typer.Option("--json", help="Output raw JSON")] = False,
+) -> None:
+    """Watch a describe-goal run until completion."""
+    import time
+    from rich.live import Live
+    from rich.text import Text
+
+    ctx = _resolve_context(json)
+    terminal_statuses = {"complete", "failed", "COMPLETED", "FAILED"}
+
+    if ctx.json_mode:
+        while True:
+            data = ctx.client.get_goal_run(id)
+            status = data.get("status", "") if isinstance(data, dict) else ""
+            ctx.print(data)
+            if status in terminal_statuses:
+                raise typer.Exit(0 if status.lower() == "complete" else 1)
+            time.sleep(interval)
+    else:
+        with Live(Text("Polling..."), refresh_per_second=1) as live:
+            while True:
+                data = ctx.client.get_goal_run(id)
+                status = data.get("status", "") if isinstance(data, dict) else ""
+                live.update(ctx.format(data))
+                if status in terminal_statuses:
+                    ctx.print(data)
+                    raise typer.Exit(0 if status.lower() == "complete" else 1)
+                time.sleep(interval)
+
+
+# ---------------------------------------------------------------------------
+# doctor
+# ---------------------------------------------------------------------------
+
+
+@doctor_app.callback(invoke_without_command=True)
+def doctor() -> None:
+    """Check CLI prerequisites and connectivity."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    checks: list[tuple[str, bool, str]] = []
+
+    py = sys.version_info
+    checks.append(
+        ("Python >= 3.12", py >= (3, 12), f"{py.major}.{py.minor}.{py.micro}")
+    )
+
+    env_token = os.environ.get("BRAVA_API_TOKEN")
+    stored = auth.load_credentials()
+    auth_ok = bool(env_token or stored)
+    if env_token:
+        detail = "via BRAVA_API_TOKEN env var"
+    elif stored:
+        detail = f"stored credentials ({stored.url})"
+    else:
+        detail = "not authenticated"
+    checks.append(("Authentication", auth_ok, detail))
+
+    url = os.environ.get("BRAVA_URL") or (stored.url if stored else None)
+    token = env_token or (stored.token if stored else None)
+    if url:
+        try:
+            import httpx
+
+            r = httpx.get(f"{url}/api/v1/health", timeout=5.0)
+            checks.append(
+                (
+                    "Platform connectivity",
+                    r.status_code == 200,
+                    f"{url} -> HTTP {r.status_code}",
+                )
+            )
+        except Exception as exc:
+            checks.append(("Platform connectivity", False, str(exc)[:80]))
+    else:
+        checks.append(("Platform connectivity", False, "no URL configured"))
+
+    if url and token:
+        try:
+            import httpx
+
+            r = httpx.get(
+                f"{url}/api/v1/attack-simulation/simulation",
+                headers={"Authorization": f"Bearer {token}"},
+                params={"limit": "1"},
+                timeout=5.0,
+            )
+            if r.status_code == 200:
+                checks.append(("Token validation", True, "token accepted by platform"))
+            elif r.status_code == 401:
+                checks.append(("Token validation", False, "invalid or expired token"))
+                auth_ok = False
+            else:
+                checks.append(
+                    ("Token validation", False, f"unexpected HTTP {r.status_code}")
+                )
+        except Exception as exc:
+            checks.append(("Token validation", False, str(exc)[:80]))
+    elif auth_ok:
+        checks.append(("Token validation", False, "skipped (no URL)"))
+
+    table = Table(title="brava doctor")
+    table.add_column("Check", style="bold")
+    table.add_column("Status")
+    table.add_column("Details")
+
+    all_ok = True
+    for name, ok, detail in checks:
+        status = "[green]OK[/green]" if ok else "[red]FAIL[/red]"
+        if not ok:
+            all_ok = False
+        table.add_row(name, status, detail)
+
+    console.print()
+    console.print(table)
+    console.print()
+    console.print(
+        "[green]All checks passed.[/green]"
+        if all_ok
+        else "[yellow]Some checks failed.[/yellow]"
+    )
+
+
+if __name__ == "__main__":
+    app()

brava_attack_simulation-0.1.0/src/simulation_cli/auth.py

@@ -0,0 +1,37 @@
+"""Credential storage and retrieval for the Brava CLI."""
+
+import json
+from pathlib import Path
+from typing import NamedTuple
+
+CONFIG_DIR = Path.home() / ".config" / "brava-cli"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+
+
+class StoredCredentials(NamedTuple):
+    token: str
+    url: str
+
+
+def store_credentials(token: str, url: str) -> None:
+    """Persist API token and URL to disk."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(json.dumps({"token": token, "url": url}))
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def load_credentials() -> StoredCredentials | None:
+    """Load stored credentials, or ``None`` if not found."""
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        data = json.loads(CREDENTIALS_FILE.read_text())
+        return StoredCredentials(token=data["token"], url=data["url"])
+    except json.JSONDecodeError, KeyError:
+        return None
+
+
+def clear_credentials() -> None:
+    """Remove stored credentials."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()

brava_attack_simulation-0.1.0/src/simulation_cli/client.py

@@ -0,0 +1,139 @@
+"""HTTP client for the Brava platform API (via BFF)."""
+
+import sys
+from typing import Any
+
+import httpx
+
+from simulation_cli.types import Snapshot
+
+
+class BravaClient:
+    """Authenticated HTTP client for the Brava BFF.
+
+    Routes requests through the backend-for-frontend which validates
+    the PAT via auth-service and proxies to downstream microservices.
+    """
+
+    def __init__(self, url: str, token: str) -> None:
+        self._http = httpx.Client(
+            base_url=url.rstrip("/"),
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            },
+            timeout=30.0,
+        )
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Snapshot:
+        try:
+            response = self._http.request(method, path, **kwargs)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            sys.exit(f"HTTP {exc.response.status_code}: {exc.response.text}")
+        except httpx.RequestError as exc:
+            sys.exit(f"Request failed: {exc}")
+        return response.json()
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> Snapshot:
+        return self._request("GET", path, params=params)
+
+    def _post(self, path: str, body: dict[str, Any]) -> Snapshot:
+        return self._request("POST", path, json=body)
+
+    # --- simulation catalog (via BFF) ---
+
+    def list_simulations(
+        self,
+        search: str | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> Snapshot:
+        params: dict[str, Any] = {}
+        if search is not None:
+            params["search"] = search
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        return self._get("/api/v1/attack-simulation/simulation", params or None)
+
+    def get_simulation(self, id: str) -> Snapshot:
+        return self._get(f"/api/v1/attack-simulation/simulation/{id}")
+
+    # --- simulation runs (via BFF) ---
+
+    def create_run(
+        self,
+        simulation_id: str,
+        account_id: str,
+        region: str,
+        params: dict[str, Any] | None = None,
+    ) -> Snapshot:
+        body: dict[str, Any] = {
+            "simulationMetadataId": simulation_id,
+            "targetAccountId": account_id,
+            "targetRegion": region,
+        }
+        if params is not None:
+            body["params"] = params
+        return self._post("/api/v1/attack-simulation/simulation-run", body)
+
+    def list_runs(
+        self,
+        account_id: str | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> Snapshot:
+        params: dict[str, Any] = {}
+        if account_id is not None:
+            params["accountId"] = account_id
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        return self._get("/api/v1/attack-simulation/simulation-run", params or None)
+
+    def get_run(self, id: str) -> Snapshot:
+        return self._get(f"/api/v1/attack-simulation/simulation-run/{id}")
+
+    # --- describe-goal runs (via BFF) ---
+
+    def create_goal_run(
+        self,
+        goal: str,
+        account_id: str,
+        region: str,
+        profile_identifier: str | None = None,
+    ) -> Snapshot:
+        body: dict[str, Any] = {
+            "goal": goal,
+            "targetAccountId": account_id,
+            "targetRegion": region,
+        }
+        if profile_identifier is not None:
+            body["profileIdentifier"] = profile_identifier
+        return self._post("/api/v1/attack-simulation/describe-goal-run", body)
+
+    def list_goal_runs(
+        self,
+        account_id: str | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> Snapshot:
+        params: dict[str, Any] = {}
+        if account_id is not None:
+            params["accountId"] = account_id
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        return self._get("/api/v1/attack-simulation/describe-goal-run", params or None)
+
+    def get_goal_run(self, id: str) -> Snapshot:
+        return self._get(f"/api/v1/attack-simulation/describe-goal-run/{id}")
+
+    # --- health ---
+
+    def health(self) -> Snapshot:
+        return self._get("/api/v1/health")

brava_attack_simulation-0.1.0/src/simulation_cli/context.py

@@ -0,0 +1,129 @@
+"""CLI context with dual-mode output (Rich for TTY, JSON for CI)."""
+
+# pyright: reportUnknownArgumentType=false, reportUnknownVariableType=false, reportUnknownMemberType=false
+
+import json
+import sys
+
+from rich.console import Console, RenderableType
+from rich.panel import Panel
+from rich.table import Table
+
+from simulation_cli.client import BravaClient
+from simulation_cli.types import Snapshot
+
+STATUS_COLORS: dict[str, str] = {
+    "planning": "yellow",
+    "executing": "blue",
+    "collecting": "cyan",
+    "complete": "green",
+    "completed": "green",
+    "failed": "red",
+    "timed_out": "red",
+    "PLANNING": "yellow",
+    "EXECUTING": "blue",
+    "COLLECTING": "cyan",
+    "COMPLETED": "green",
+    "FAILED": "red",
+    "TIMED_OUT": "red",
+}
+
+PREFERRED_COLUMNS: list[str] = [
+    "id",
+    "cid",
+    "name",
+    "status",
+    "goal",
+    "simulationMetadataId",
+    "targetAccountId",
+    "targetRegion",
+    "provider",
+    "createdAt",
+]
+
+
+class CliContext:
+    """Holds the authenticated client and output mode."""
+
+    def __init__(self, client: BravaClient, json_mode: bool = False) -> None:
+        self.client = client
+        self.json_mode = json_mode or not sys.stdout.isatty()
+        self.console = Console()
+
+    def print(self, data: Snapshot) -> None:
+        if self.json_mode:
+            print(json.dumps(data, indent=2, default=str))
+        else:
+            self.console.print(self.format(data))
+
+    def format(self, data: Snapshot) -> RenderableType:
+        if isinstance(data, list):
+            return _format_list(data)
+        if "data" in data and isinstance(data["data"], list):
+            return _format_paginated(data)
+        return _format_dict(data)
+
+
+def _format_list(items: list[dict[str, object] | object]) -> Table:
+    if not items:
+        return Table(title="No results")
+
+    first = items[0]
+    if not isinstance(first, dict):
+        table = Table(show_lines=False)
+        table.add_column("value")
+        for item in items:
+            table.add_row(str(item))
+        return table
+
+    all_keys: list[str] = list(first.keys())
+    keys = [k for k in PREFERRED_COLUMNS if k in all_keys]
+    if not keys:
+        keys = [k for k in all_keys if not isinstance(first.get(k), (dict, list))][:8]
+
+    table = Table(show_lines=False)
+    for key in keys:
+        table.add_column(key, style="bold" if key in ("id", "cid", "name") else "")
+
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        row: list[str] = []
+        for key in keys:
+            val = item.get(key, "")
+            if key == "status":
+                color = STATUS_COLORS.get(str(val), "white")
+                row.append(f"[{color}]{val}[/{color}]")
+            elif key == "createdAt" and isinstance(val, str) and len(val) > 10:
+                row.append(val[:10])
+            else:
+                s = str(val) if val is not None else ""
+                row.append(s[:60] + "..." if len(s) > 60 else s)
+        table.add_row(*row)
+    return table
+
+
+def _format_paginated(data: dict[str, object]) -> Table:
+    items = data["data"]
+    assert isinstance(items, list)
+    total = data.get("total", len(items))
+    table = _format_list(items)
+    table.caption = f"Showing {len(items)} of {total}"
+    return table
+
+
+def _format_dict(data: dict[str, object]) -> Panel:
+    lines: list[str] = []
+    for key, val in data.items():
+        if key == "status":
+            color = STATUS_COLORS.get(str(val), "white")
+            lines.append(f"[bold]{key}:[/bold] [{color}]{val}[/{color}]")
+        elif isinstance(val, list) and len(val) > 3:
+            lines.append(f"[bold]{key}:[/bold] ({len(val)} items)")
+        elif isinstance(val, dict):
+            lines.append(f"[bold]{key}:[/bold] {{...}}")
+        else:
+            lines.append(f"[bold]{key}:[/bold] {val}")
+
+    title = str(data.get("id", data.get("name", "Result")))
+    return Panel("\n".join(lines), title=title, expand=False)

brava_attack_simulation-0.1.0/src/simulation_cli/types.py

@@ -0,0 +1,10 @@
+"""Shared type aliases for simulation_cli.
+
+TODO: Replace Snapshot with typed Pydantic DTOs from brava-attack-simulation-manager
+      once generate-pydantic is wired into the manager CI pipeline and the package
+      is republished with REST API response models.
+"""
+
+from typing import Any
+
+Snapshot = dict[str, Any] | list[Any]

brava_attack_simulation-0.1.0/uv.lock

@@ -0,0 +1,263 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "brava-cli"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "httpx" },
+    { name = "python-dotenv" },
+    { name = "rich" },
+    { name = "typer" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pyright" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "httpx", specifier = ">=0.28.0" },
+    { name = "python-dotenv", specifier = ">=1.0.0" },
+    { name = "rich", specifier = ">=13.0.0" },
+    { name = "typer", specifier = ">=0.15.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pyright", specifier = ">=1.1.408" },
+    { name = "ruff", specifier = ">=0.15.9" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/75/31212c6bf2503fdf920d87fee5d7a86a2e3bcf444984126f13d8e4016804/click-8.3.2.tar.gz", hash = "sha256:14162b8b3b3550a7d479eafa77dfd3c38d9dc8951f6f69c78913a8f9a7540fd5", size = 302856, upload-time = "2026-04-03T19:14:45.118Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/20/71885d8b97d4f3dde17b1fdb92dbd4908b00541c5a3379787137285f602e/click-8.3.2-py3-none-any.whl", hash = "sha256:1924d2c27c5653561cd2cae4548d1406039cb79b858b747cfea24924bbc1616d", size = 108379, upload-time = "2026-04-03T19:14:43.505Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.408"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/b2/5db700e52554b8f025faa9c3c624c59f1f6c8841ba81ab97641b54322f16/pyright-1.1.408.tar.gz", hash = "sha256:f28f2321f96852fa50b5829ea492f6adb0e6954568d1caa3f3af3a5f555eb684", size = 4400578, upload-time = "2026-01-08T08:07:38.795Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/82/a2c93e32800940d9573fb28c346772a14778b84ba7524e691b324620ab89/pyright-1.1.408-py3-none-any.whl", hash = "sha256:090b32865f4fdb1e0e6cd82bf5618480d48eecd2eb2e70f960982a3d9a4c17c1", size = 6399144, upload-time = "2026-01-08T08:07:37.082Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/97/e9f1ca355108ef7194e38c812ef40ba98c7208f47b13ad78d023caa583da/ruff-0.15.9.tar.gz", hash = "sha256:29cbb1255a9797903f6dde5ba0188c707907ff44a9006eb273b5a17bfa0739a2", size = 4617361, upload-time = "2026-04-02T18:17:20.829Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/1f/9cdfd0ac4b9d1e5a6cf09bedabdf0b56306ab5e333c85c87281273e7b041/ruff-0.15.9-py3-none-linux_armv6l.whl", hash = "sha256:6efbe303983441c51975c243e26dff328aca11f94b70992f35b093c2e71801e1", size = 10511206, upload-time = "2026-04-02T18:16:41.574Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/f6/32bfe3e9c136b35f02e489778d94384118bb80fd92c6d92e7ccd97db12ce/ruff-0.15.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4965bac6ac9ea86772f4e23587746f0b7a395eccabb823eb8bfacc3fa06069f7", size = 10923307, upload-time = "2026-04-02T18:17:08.645Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/25/de55f52ab5535d12e7aaba1de37a84be6179fb20bddcbe71ec091b4a3243/ruff-0.15.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:eaf05aad70ca5b5a0a4b0e080df3a6b699803916d88f006efd1f5b46302daab8", size = 10316722, upload-time = "2026-04-02T18:16:44.206Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/690d75f3fd6278fe55fff7c9eb429c92d207e14b25d1cae4064a32677029/ruff-0.15.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9439a342adb8725f32f92732e2bafb6d5246bd7a5021101166b223d312e8fc59", size = 10623674, upload-time = "2026-04-02T18:16:50.951Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/ec/176f6987be248fc5404199255522f57af1b4a5a1b57727e942479fec98ad/ruff-0.15.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9c5e6faf9d97c8edc43877c3f406f47446fc48c40e1442d58cfcdaba2acea745", size = 10351516, upload-time = "2026-04-02T18:16:57.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fc/51cffbd2b3f240accc380171d51446a32aa2ea43a40d4a45ada67368fbd2/ruff-0.15.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7b34a9766aeec27a222373d0b055722900fbc0582b24f39661aa96f3fe6ad901", size = 11150202, upload-time = "2026-04-02T18:17:06.452Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/d4/25292a6dfc125f6b6528fe6af31f5e996e19bf73ca8e3ce6eb7fa5b95885/ruff-0.15.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:89dd695bc72ae76ff484ae54b7e8b0f6b50f49046e198355e44ea656e521fef9", size = 11988891, upload-time = "2026-04-02T18:17:18.575Z" },
+    { url = "https://files.pythonhosted.org/packages/13/e1/1eebcb885c10e19f969dcb93d8413dfee8172578709d7ee933640f5e7147/ruff-0.15.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce187224ef1de1bd225bc9a152ac7102a6171107f026e81f317e4257052916d5", size = 11480576, upload-time = "2026-04-02T18:16:52.986Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/a1548ac378a78332a4c3dcf4a134c2475a36d2a22ddfa272acd574140b50/ruff-0.15.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b0c7c341f68adb01c488c3b7d4b49aa8ea97409eae6462d860a79cf55f431b6", size = 11254525, upload-time = "2026-04-02T18:17:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/42/aa/4bb3af8e61acd9b1281db2ab77e8b2c3c5e5599bf2a29d4a942f1c62b8d6/ruff-0.15.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:55cc15eee27dc0eebdfcb0d185a6153420efbedc15eb1d38fe5e685657b0f840", size = 11204072, upload-time = "2026-04-02T18:17:13.581Z" },
+    { url = "https://files.pythonhosted.org/packages/69/48/d550dc2aa6e423ea0bcc1d0ff0699325ffe8a811e2dba156bd80750b86dc/ruff-0.15.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a6537f6eed5cda688c81073d46ffdfb962a5f29ecb6f7e770b2dc920598997ed", size = 10594998, upload-time = "2026-04-02T18:16:46.369Z" },
+    { url = "https://files.pythonhosted.org/packages/63/47/321167e17f5344ed5ec6b0aa2cff64efef5f9e985af8f5622cfa6536043f/ruff-0.15.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:6d3fcbca7388b066139c523bda744c822258ebdcfbba7d24410c3f454cc9af71", size = 10359769, upload-time = "2026-04-02T18:17:10.994Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5e/074f00b9785d1d2c6f8c22a21e023d0c2c1817838cfca4c8243200a1fa87/ruff-0.15.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:058d8e99e1bfe79d8a0def0b481c56059ee6716214f7e425d8e737e412d69677", size = 10850236, upload-time = "2026-04-02T18:16:48.749Z" },
+    { url = "https://files.pythonhosted.org/packages/76/37/804c4135a2a2caf042925d30d5f68181bdbd4461fd0d7739da28305df593/ruff-0.15.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:8e1ddb11dbd61d5983fa2d7d6370ef3eb210951e443cace19594c01c72abab4c", size = 11358343, upload-time = "2026-04-02T18:16:55.068Z" },
+    { url = "https://files.pythonhosted.org/packages/88/3d/1364fcde8656962782aa9ea93c92d98682b1ecec2f184e625a965ad3b4a6/ruff-0.15.9-py3-none-win32.whl", hash = "sha256:bde6ff36eaf72b700f32b7196088970bf8fdb2b917b7accd8c371bfc0fd573ec", size = 10583382, upload-time = "2026-04-02T18:17:04.261Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/56/5c7084299bd2cacaa07ae63a91c6f4ba66edc08bf28f356b24f6b717c799/ruff-0.15.9-py3-none-win_amd64.whl", hash = "sha256:45a70921b80e1c10cf0b734ef09421f71b5aa11d27404edc89d7e8a69505e43d", size = 11744969, upload-time = "2026-04-02T18:16:59.611Z" },
+    { url = "https://files.pythonhosted.org/packages/03/36/76704c4f312257d6dbaae3c959add2a622f63fcca9d864659ce6d8d97d3d/ruff-0.15.9-py3-none-win_arm64.whl", hash = "sha256:0694e601c028fd97dc5c6ee244675bc241aeefced7ef80cd9c6935a871078f53", size = 11005870, upload-time = "2026-04-02T18:17:15.773Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]