honeycomb-api 0.1.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

honeycomb/cli/config.py

@@ -0,0 +1,259 @@
+"""
+Configuration management for the Honeycomb CLI.
+
+Handles profiles, credentials, and client initialization.
+"""
+
+import os
+from pathlib import Path
+from typing import Any
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from honeycomb import HoneycombClient
+
+app = typer.Typer(help="Manage CLI configuration and profiles")
+console = Console()
+
+CONFIG_DIR = Path.home() / ".honeycomb"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+def _ensure_config_dir() -> None:
+    """Ensure the config directory exists."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+
+
+def _load_config() -> dict[str, Any]:
+    """Load the config file, returning empty dict if it doesn't exist."""
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE) as f:
+        return yaml.safe_load(f) or {}
+
+
+def _save_config(config: dict[str, Any]) -> None:
+    """Save the config file."""
+    _ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        yaml.safe_dump(config, f, default_flow_style=False)
+
+
+def get_api_key_from_config(profile: str | None = None) -> str | None:
+    """
+    Get API key from environment or config.
+
+    Priority order:
+    1. Environment variable (HONEYCOMB_API_KEY)
+    2. Profile from config file
+    3. Default profile from config file
+
+    Returns:
+        API key string or None if not found
+    """
+    # Try environment variable
+    env_api_key = os.environ.get("HONEYCOMB_API_KEY")
+    if env_api_key:
+        return env_api_key
+
+    # Try profile from config file
+    config = _load_config()
+    profiles = config.get("profiles", {})
+
+    # Use specified profile or default
+    profile_name = profile or config.get("default_profile")
+    if not profile_name or profile_name not in profiles:
+        return None
+
+    return profiles[profile_name].get("api_key")
+
+
+def get_client(
+    profile: str | None = None,
+    api_key: str | None = None,
+    management_key: str | None = None,
+    management_secret: str | None = None,
+    base_url: str | None = None,
+) -> HoneycombClient:
+    """
+    Get a configured Honeycomb client.
+
+    Priority order:
+    1. Explicit parameters (api_key, management_key, etc.)
+    2. Environment variables (HONEYCOMB_API_KEY, etc.)
+    3. Profile from config file
+    4. Default profile from config file
+    """
+    # If explicit credentials provided, use them
+    if api_key or management_key:
+        return HoneycombClient(
+            api_key=api_key,
+            management_key=management_key,
+            management_secret=management_secret,
+            base_url=base_url or "https://api.honeycomb.io",
+            sync=True,
+        )
+
+    # Try environment variables
+    env_api_key = os.environ.get("HONEYCOMB_API_KEY")
+    env_mgmt_key = os.environ.get("HONEYCOMB_MANAGEMENT_KEY")
+    env_mgmt_secret = os.environ.get("HONEYCOMB_MANAGEMENT_SECRET")
+
+    if env_api_key or env_mgmt_key:
+        return HoneycombClient(
+            api_key=env_api_key,
+            management_key=env_mgmt_key,
+            management_secret=env_mgmt_secret,
+            base_url=base_url or "https://api.honeycomb.io",
+            sync=True,
+        )
+
+    # Try profile from config file
+    config = _load_config()
+    profiles = config.get("profiles", {})
+
+    # Use specified profile or default
+    profile_name = profile or config.get("default_profile")
+
+    if not profile_name:
+        console.print(
+            "[red]Error:[/red] No credentials found. Provide --api-key or configure a profile.",
+            style="bold",
+        )
+        raise typer.Exit(1)
+
+    if profile_name not in profiles:
+        console.print(
+            f"[red]Error:[/red] Profile '{profile_name}' not found in {CONFIG_FILE}",
+            style="bold",
+        )
+        raise typer.Exit(1)
+
+    profile_config = profiles[profile_name]
+    return HoneycombClient(
+        api_key=profile_config.get("api_key"),
+        management_key=profile_config.get("management_key"),
+        management_secret=profile_config.get("management_secret"),
+        base_url=profile_config.get("base_url", "https://api.honeycomb.io"),
+        sync=True,
+    )
+
+
+@app.command("show")
+def show_config() -> None:
+    """Show current configuration."""
+    if not CONFIG_FILE.exists():
+        console.print(f"[yellow]No config file found at {CONFIG_FILE}[/yellow]")
+        return
+
+    config = _load_config()
+
+    # Display default profile
+    default_profile = config.get("default_profile")
+    if default_profile:
+        console.print(f"[bold]Default profile:[/bold] {default_profile}\n")
+    else:
+        console.print("[yellow]No default profile set[/yellow]\n")
+
+    # Display profiles table
+    profiles = config.get("profiles", {})
+    if not profiles:
+        console.print("[yellow]No profiles configured[/yellow]")
+        return
+
+    table = Table(title="Profiles")
+    table.add_column("Name", style="cyan")
+    table.add_column("API Key", style="green")
+    table.add_column("Management Key", style="green")
+    table.add_column("Base URL", style="blue")
+
+    for name, profile in profiles.items():
+        api_key = profile.get("api_key", "")
+        mgmt_key = profile.get("management_key", "")
+        base_url = profile.get("base_url", "https://api.honeycomb.io")
+
+        # Mask keys for security
+        api_key_display = f"{api_key[:10]}..." if api_key else "-"
+        mgmt_key_display = f"{mgmt_key[:10]}..." if mgmt_key else "-"
+
+        table.add_row(name, api_key_display, mgmt_key_display, base_url)
+
+    console.print(table)
+
+
+@app.command("add-profile")
+def add_profile(
+    name: str = typer.Argument(..., help="Profile name"),
+    api_key: str | None = typer.Option(None, "--api-key", help="API key"),
+    management_key: str | None = typer.Option(None, "--management-key", help="Management key"),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", help="Management secret"
+    ),
+    base_url: str | None = typer.Option(
+        None, "--base-url", help="Base URL (default: https://api.honeycomb.io)"
+    ),
+    set_default: bool = typer.Option(False, "--set-default", help="Set as default profile"),
+) -> None:
+    """Add or update a profile."""
+    if not api_key and not management_key:
+        console.print("[red]Error:[/red] Must provide --api-key or --management-key", style="bold")
+        raise typer.Exit(1)
+
+    if management_key and not management_secret:
+        console.print(
+            "[red]Error:[/red] --management-secret required when using --management-key",
+            style="bold",
+        )
+        raise typer.Exit(1)
+
+    config = _load_config()
+    if "profiles" not in config:
+        config["profiles"] = {}
+
+    config["profiles"][name] = {}
+    if api_key:
+        config["profiles"][name]["api_key"] = api_key
+    if management_key:
+        config["profiles"][name]["management_key"] = management_key
+        config["profiles"][name]["management_secret"] = management_secret
+    if base_url:
+        config["profiles"][name]["base_url"] = base_url
+
+    if set_default:
+        config["default_profile"] = name
+
+    _save_config(config)
+    console.print(f"[green]Profile '{name}' saved to {CONFIG_FILE}[/green]")
+
+
+@app.command("remove-profile")
+def remove_profile(name: str = typer.Argument(..., help="Profile name")) -> None:
+    """Remove a profile."""
+    config = _load_config()
+    profiles = config.get("profiles", {})
+
+    if name not in profiles:
+        console.print(f"[red]Error:[/red] Profile '{name}' not found", style="bold")
+        raise typer.Exit(1)
+
+    del profiles[name]
+    _save_config(config)
+    console.print(f"[green]Profile '{name}' removed[/green]")
+
+
+@app.command("set-default")
+def set_default(name: str = typer.Argument(..., help="Profile name")) -> None:
+    """Set the default profile."""
+    config = _load_config()
+    profiles = config.get("profiles", {})
+
+    if name not in profiles:
+        console.print(f"[red]Error:[/red] Profile '{name}' not found", style="bold")
+        raise typer.Exit(1)
+
+    config["default_profile"] = name
+    _save_config(config)
+    console.print(f"[green]Default profile set to '{name}'[/green]")

honeycomb/cli/datasets.py

@@ -0,0 +1,186 @@
+"""
+Dataset management commands.
+"""
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from honeycomb.cli.config import get_client
+from honeycomb.cli.formatters import DEFAULT_OUTPUT_FORMAT, OutputFormat, output_result
+from honeycomb.models.datasets import DatasetCreate, DatasetUpdate
+
+app = typer.Typer(help="Manage datasets")
+console = Console()
+
+
+@app.command("list")
+def list_datasets(
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Only output dataset slugs"),
+) -> None:
+    """List all datasets in the environment."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        datasets = client.datasets.list()
+        output_result(
+            datasets, output, columns=["slug", "name", "description", "created_at"], quiet=quiet
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_dataset(
+    slug: str = typer.Argument(..., help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Get a specific dataset."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        dataset = client.datasets.get(slug=slug)
+        output_result(dataset, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_dataset(
+    name: str | None = typer.Option(None, "--name", "-n", help="Dataset name"),
+    slug: str | None = typer.Option(None, "--slug", "-s", help="Dataset slug"),
+    description: str | None = typer.Option(None, "--description", "-d", help="Dataset description"),
+    from_file: Path | None = typer.Option(
+        None, "--from-file", "-f", help="JSON file with dataset config"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Create a new dataset."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        if from_file:
+            # Load from JSON file
+            data = json.loads(from_file.read_text())
+            data.pop("created_at", None)
+            data.pop("updated_at", None)
+            dataset_create = DatasetCreate.model_validate(data)
+        elif name and slug:
+            # Create from CLI arguments
+            dataset_create = DatasetCreate(name=name, slug=slug, description=description)
+        else:
+            console.print(
+                "[red]Error:[/red] Provide --name and --slug, or --from-file", style="bold"
+            )
+            raise typer.Exit(1)
+
+        dataset = client.datasets.create(dataset=dataset_create)
+
+        console.print(f"[green]Created dataset '{dataset.name}' with slug: {dataset.slug}[/green]")
+        output_result(dataset, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_dataset(
+    slug: str = typer.Argument(..., help="Dataset slug"),
+    name: str | None = typer.Option(None, "--name", "-n", help="New dataset name"),
+    description: str | None = typer.Option(None, "--description", "-d", help="New description"),
+    delete_protected: bool | None = typer.Option(
+        None, "--delete-protected/--no-delete-protected", help="Enable/disable delete protection"
+    ),
+    from_file: Path | None = typer.Option(
+        None, "--from-file", "-f", help="JSON file with dataset config"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Update an existing dataset.
+
+    Examples:
+        hny datasets update my-dataset --description "Updated description"
+        hny datasets update my-dataset --delete-protected
+        hny datasets update my-dataset --no-delete-protected
+    """
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        update_payload: DatasetCreate | DatasetUpdate
+        if from_file:
+            # Load from JSON file
+            data = json.loads(from_file.read_text())
+            data.pop("slug", None)  # Can't change slug
+            data.pop("created_at", None)
+            data.pop("updated_at", None)
+            update_payload = DatasetCreate.model_validate(data)
+        elif name or description is not None or delete_protected is not None:
+            # Use DatasetUpdate for partial updates
+            update_payload = DatasetUpdate(
+                name=name,
+                description=description,
+                delete_protected=delete_protected,
+            )
+        else:
+            console.print(
+                "[red]Error:[/red] Provide --name, --description, "
+                "--delete-protected/--no-delete-protected, or --from-file",
+                style="bold",
+            )
+            raise typer.Exit(1)
+
+        dataset = client.datasets.update(slug=slug, dataset=update_payload)
+
+        console.print(f"[green]Updated dataset '{dataset.name}'[/green]")
+        output_result(dataset, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_dataset(
+    slug: str = typer.Argument(..., help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+    remove_delete_protection: bool = typer.Option(
+        False, "--remove-delete-protection", help="Remove delete protection before deleting"
+    ),
+) -> None:
+    """Delete a dataset.
+
+    If the dataset has delete protection enabled, use --remove-delete-protection
+    to disable it before deleting.
+    """
+    try:
+        if not yes:
+            confirm = typer.confirm(
+                f"Delete dataset '{slug}' and ALL its data (triggers, SLOs, queries, events)?"
+            )
+            if not confirm:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        client = get_client(profile=profile, api_key=api_key)
+
+        if remove_delete_protection:
+            console.print(f"Removing delete protection from '{slug}'...")
+            client.datasets.set_delete_protected(slug=slug, protected=False)
+
+        client.datasets.delete(slug=slug)
+        console.print(f"[green]Deleted dataset '{slug}'[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)

honeycomb/cli/derived_columns.py

@@ -0,0 +1,222 @@
+"""
+Derived column (calculated field) management commands.
+"""
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from honeycomb.cli.config import get_client
+from honeycomb.cli.formatters import DEFAULT_OUTPUT_FORMAT, OutputFormat, output_result
+from honeycomb.models.derived_columns import DerivedColumnCreate
+
+app = typer.Typer(help="Manage derived columns (calculated fields)")
+console = Console()
+
+
+@app.command("list")
+def list_derived_columns(
+    dataset: str = typer.Option(
+        "__all__", "--dataset", "-d", help="Dataset slug (default: __all__ for environment-wide)"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Only output column IDs"),
+) -> None:
+    """List all derived columns (environment-wide by default, or in a specific dataset)."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        columns = client.derived_columns.list(dataset=dataset)
+        output_result(
+            columns,
+            output,
+            columns=["id", "alias", "expression", "description", "created_at"],
+            quiet=quiet,
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_derived_column(
+    column_id: str = typer.Argument(..., help="Derived column ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Get a specific derived column."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        column = client.derived_columns.get(dataset=dataset, column_id=column_id)
+        output_result(column, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_derived_column(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(
+        ..., "--from-file", "-f", help="JSON file with derived column config"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Create a derived column from a JSON file."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # Load and parse JSON file
+        data = json.loads(from_file.read_text())
+
+        # Strip fields that shouldn't be in create request
+        data.pop("id", None)
+        data.pop("created_at", None)
+        data.pop("updated_at", None)
+
+        column_create = DerivedColumnCreate.model_validate(data)
+        column = client.derived_columns.create(dataset=dataset, derived_column=column_create)
+
+        console.print(
+            f"[green]Created derived column '{column.alias}' with ID: {column.id}[/green]"
+        )
+        output_result(column, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_derived_column(
+    column_id: str = typer.Argument(..., help="Derived column ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(
+        ..., "--from-file", "-f", help="JSON file with derived column config"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Update an existing derived column."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # Load and parse JSON file
+        data = json.loads(from_file.read_text())
+
+        # Strip fields that shouldn't be in update request
+        data.pop("id", None)
+        data.pop("created_at", None)
+        data.pop("updated_at", None)
+
+        column_update = DerivedColumnCreate.model_validate(data)
+        column = client.derived_columns.update(
+            dataset=dataset, column_id=column_id, derived_column=column_update
+        )
+
+        console.print(f"[green]Updated derived column '{column.alias}'[/green]")
+        output_result(column, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_derived_column(
+    column_id: str = typer.Argument(..., help="Derived column ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Delete a derived column."""
+    try:
+        if not yes:
+            confirm = typer.confirm(f"Delete derived column {column_id} from dataset {dataset}?")
+            if not confirm:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        client = get_client(profile=profile, api_key=api_key)
+        client.derived_columns.delete(dataset=dataset, column_id=column_id)
+        console.print(f"[green]Deleted derived column {column_id}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export")
+def export_derived_column(
+    column_id: str = typer.Argument(..., help="Derived column ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output_file: Path | None = typer.Option(
+        None, "--output-file", "-o", help="Output file (default: stdout)"
+    ),
+) -> None:
+    """
+    Export a derived column as JSON.
+
+    Output is suitable for importing to another environment via the 'create' command.
+    """
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        column = client.derived_columns.get(dataset=dataset, column_id=column_id)
+
+        # Export without IDs/timestamps for portability
+        data = column.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+        json_str = json.dumps(data, indent=2, default=str)
+
+        if output_file:
+            output_file.write_text(json_str)
+            console.print(f"[green]Exported derived column to {output_file}[/green]")
+        else:
+            console.print(json_str)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export-all")
+def export_all_derived_columns(
+    dataset: str = typer.Option(
+        "__all__", "--dataset", "-d", help="Dataset slug (default: __all__ for environment-wide)"
+    ),
+    output_dir: Path = typer.Option(..., "--output-dir", help="Output directory"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+) -> None:
+    """Export all derived columns to individual JSON files."""
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        client = get_client(profile=profile, api_key=api_key)
+        columns = client.derived_columns.list(dataset=dataset)
+
+        for column in columns:
+            # Export without IDs/timestamps
+            data = column.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+
+            # Sanitize filename (replace special chars with dash)
+            filename = f"{column.alias}.json".replace("/", "-").replace(" ", "-").lower()
+            file_path = output_dir / filename
+
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=2, default=str)
+
+            console.print(f"[green]Exported '{column.alias}' to {file_path}[/green]")
+
+        console.print(
+            f"\n[bold green]Exported {len(columns)} derived columns to {output_dir}[/bold green]"
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)