hackagent 0.3.1__py3-none-any.whl

hackagent/cli/commands/config.py

@@ -0,0 +1,301 @@
+# Copyright 2025 - AI4I. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Configuration Commands
+
+Manage HackAgent CLI configuration settings.
+"""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from hackagent.cli.config import CLIConfig
+from hackagent.cli.utils import display_info, display_success, handle_errors
+
+console = Console()
+
+
+@click.group()
+def config():
+    """🔧 Manage HackAgent CLI configuration"""
+    pass
+
+
+@config.command()
+@click.option("--api-key", help="HackAgent API key")
+@click.option("--base-url", help="HackAgent API base URL")
+@click.option(
+    "--output-format",
+    type=click.Choice(["table", "json", "csv"]),
+    help="Default output format",
+)
+@click.option(
+    "--verbose",
+    type=str,
+    help="Default verbosity level: 0/error, 1/warning, 2/info, 3/debug",
+)
+@click.pass_context
+@handle_errors
+def set(ctx, api_key, base_url, output_format, verbose):
+    """Set configuration values"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+
+    updated = False
+
+    if api_key:
+        cli_config.api_key = api_key
+        updated = True
+        if cli_config.should_show_info():
+            display_success("API key updated")
+
+    if base_url:
+        cli_config.base_url = base_url
+        updated = True
+        if cli_config.should_show_info():
+            display_success(f"Base URL updated to: {base_url}")
+
+    if output_format:
+        cli_config.output_format = output_format
+        updated = True
+        if cli_config.should_show_info():
+            display_success(f"Output format updated to: {output_format}")
+
+    if verbose is not None:
+        from hackagent.cli.config import VERBOSITY_LEVELS, VERBOSITY_NAMES
+
+        # Try to parse as integer first, then as name
+        try:
+            verbose_int = int(verbose)
+            if 0 <= verbose_int <= 3:
+                cli_config.verbose = verbose_int
+                updated = True
+                if cli_config.verbose > 0:
+                    display_success(
+                        f"Verbosity level updated to: {verbose_int} ({VERBOSITY_NAMES[verbose_int]})"
+                    )
+            else:
+                display_info("Verbosity level must be between 0 and 3")
+        except ValueError:
+            # Try as name
+            verbose_lower = verbose.lower()
+            if verbose_lower in VERBOSITY_LEVELS:
+                verbose_int = VERBOSITY_LEVELS[verbose_lower]
+                cli_config.verbose = verbose_int
+                updated = True
+                if cli_config.verbose > 0:
+                    display_success(
+                        f"Verbosity level updated to: {verbose_int} ({VERBOSITY_NAMES[verbose_int]})"
+                    )
+            else:
+                display_info(
+                    f"Invalid verbosity level. Use: 0-3 or {', '.join(VERBOSITY_LEVELS.keys())}"
+                )
+
+    if updated:
+        cli_config.save()
+        display_success("✅ Configuration saved")
+    else:
+        display_info("No configuration changes made")
+
+
+@config.command()
+@click.pass_context
+@handle_errors
+def show(ctx):
+    """Show current configuration"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+
+    table = Table(
+        title="HackAgent Configuration", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_column("Source", style="dim")
+
+    # Determine sources
+    api_key_source = "Not set"
+    if cli_config.api_key:
+        if ctx.params.get("api_key"):
+            api_key_source = "CLI argument"
+        elif cli_config.config_file:
+            api_key_source = f"Config file ({cli_config.config_file})"
+        else:
+            api_key_source = "Environment/Default config"
+
+    base_url_source = "Default"
+    if cli_config.base_url != "https://api.hackagent.dev":
+        if ctx.params.get("base_url"):
+            base_url_source = "CLI argument"
+        elif cli_config.config_file:
+            base_url_source = f"Config file ({cli_config.config_file})"
+        else:
+            base_url_source = "Environment/Default config"
+
+    # Add rows
+    api_key_display = (
+        cli_config.api_key[:8] + "..." if cli_config.api_key else "Not set"
+    )
+    from hackagent.cli.config import VERBOSITY_NAMES
+
+    table.add_row("API Key", api_key_display, api_key_source)
+    table.add_row("Base URL", cli_config.base_url, base_url_source)
+    table.add_row("Output Format", cli_config.output_format, "Default/Config")
+    verbosity_display = (
+        f"{cli_config.verbose} ({VERBOSITY_NAMES.get(cli_config.verbose, 'UNKNOWN')})"
+    )
+    table.add_row("Verbosity", verbosity_display, "Default/Config")
+    table.add_row(
+        "Config File", str(cli_config.default_config_path), "Default location"
+    )
+
+    console.print(table)
+
+    # Show config file status only in info mode or higher
+    if cli_config.should_show_info():
+        if cli_config.default_config_path.exists():
+            display_info(f"Configuration file: {cli_config.default_config_path}")
+        else:
+            display_info(
+                "No configuration file found. Use 'hackagent config set' to create one."
+            )
+
+
+@config.command()
+@click.option("--confirm", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+@handle_errors
+def reset(ctx, confirm):
+    """Reset configuration to defaults"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+
+    if not confirm:
+        if not click.confirm(
+            "⚠️ This will reset all configuration to defaults. Continue?"
+        ):
+            display_info("Configuration reset cancelled")
+            return
+
+    # Remove config file if it exists
+    if cli_config.default_config_path.exists():
+        cli_config.default_config_path.unlink()
+        display_success("✅ Configuration reset to defaults")
+        if cli_config.should_show_info():
+            display_info(
+                "API key will need to be set again using environment variable or 'hackagent config set --api-key'"
+            )
+    else:
+        display_info("No configuration file to reset")
+
+
+@config.command()
+@click.pass_context
+@handle_errors
+def validate(ctx):
+    """Validate current configuration"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+
+    try:
+        cli_config.validate()
+
+        # Test API connection
+        if cli_config.should_show_info():
+            with console.status("[bold green]Testing API connection..."):
+                from hackagent.client import AuthenticatedClient
+
+                client = AuthenticatedClient(
+                    base_url=cli_config.base_url,
+                    token=cli_config.api_key,
+                    prefix="Bearer",
+                )
+
+                # Try to make a simple API call to test connection
+                from hackagent.api.key import key_list
+
+                response = key_list.sync_detailed(client=client)
+        else:
+            from hackagent.client import AuthenticatedClient
+
+            client = AuthenticatedClient(
+                base_url=cli_config.base_url, token=cli_config.api_key, prefix="Bearer"
+            )
+            from hackagent.api.key import key_list
+
+            response = key_list.sync_detailed(client=client)
+
+        if response.status_code == 200:
+            display_success("✅ Configuration valid - API connection successful")
+        else:
+            console.print(
+                f"[yellow]⚠️ Configuration valid but API connection issue: Status {response.status_code}"
+            )
+
+    except ValueError as e:
+        console.print(f"[red]❌ Configuration validation failed: {e}")
+        console.print("\n[cyan]💡 Quick fixes:")
+        console.print("  • Set API key: hackagent config set --api-key YOUR_KEY")
+        console.print(
+            "  • Set base URL: hackagent config set --base-url https://api.hackagent.dev"
+        )
+        raise click.ClickException("Configuration validation failed")
+    except Exception as e:
+        console.print(f"[yellow]⚠️ Could not test API connection: {e}")
+        display_info(
+            "Configuration appears valid, but API connection could not be tested"
+        )
+
+
+@config.command()
+@click.argument("config_file", type=click.Path(exists=True))
+@click.pass_context
+@handle_errors
+def import_config(ctx, config_file):
+    """Import configuration from a file"""
+
+    from hackagent.cli.utils import load_config_file
+
+    try:
+        config_data = load_config_file(config_file)
+
+        cli_config: CLIConfig = ctx.obj["config"]
+
+        # Update configuration
+        updated_fields = []
+        if "api_key" in config_data:
+            cli_config.api_key = config_data["api_key"]
+            updated_fields.append("API key")
+
+        if "base_url" in config_data:
+            cli_config.base_url = config_data["base_url"]
+            updated_fields.append("Base URL")
+
+        if "output_format" in config_data:
+            cli_config.output_format = config_data["output_format"]
+            updated_fields.append("Output format")
+
+        if updated_fields:
+            cli_config.save()
+            display_success(f"✅ Configuration imported: {', '.join(updated_fields)}")
+            if cli_config.should_show_info():
+                display_info(f"Saved to: {cli_config.default_config_path}")
+        else:
+            display_info("No valid configuration found in file")
+
+    except Exception as e:
+        raise click.ClickException(f"Failed to import configuration: {e}")

hackagent/cli/commands/results.py

@@ -0,0 +1,327 @@
+# Copyright 2025 - AI4I. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Results Commands
+
+View and manage attack results.
+"""
+
+from datetime import datetime
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from hackagent.cli.config import CLIConfig
+from hackagent.cli.utils import handle_errors, launch_tui
+
+console = Console()
+
+
+@click.group()
+def results():
+    """📊 View and manage attack results"""
+    # Show logo when results commands are used
+    _show_logo_once()
+
+
+def _show_logo_once():
+    """Show the logo once per session"""
+    if not hasattr(_show_logo_once, "_shown"):
+        from hackagent.utils import display_hackagent_splash
+
+        display_hackagent_splash()
+        _show_logo_once._shown = True
+
+
+@results.command()
+@click.option("--limit", default=10, help="Number of results to show")
+@click.option(
+    "--status",
+    type=click.Choice(["pending", "running", "completed", "failed"]),
+    help="Filter by status",
+)
+@click.option("--agent", help="Filter by agent name")
+@click.option("--attack-type", help="Filter by attack type")
+@click.pass_context
+@handle_errors
+def list(ctx, limit, status, agent, attack_type):
+    """List recent attack results"""
+    cli_config: CLIConfig = ctx.obj["config"]
+    cli_config.validate()
+    launch_tui(cli_config, initial_tab="results")
+
+
+@results.command()
+@click.argument("result_id")
+@click.pass_context
+@handle_errors
+def show(ctx, result_id):
+    """Show detailed information about a specific result"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+    cli_config.validate()
+
+    try:
+        from hackagent.api.result import result_retrieve
+        from hackagent.client import AuthenticatedClient
+
+        client = AuthenticatedClient(
+            base_url=cli_config.base_url, token=cli_config.api_key, prefix="Bearer"
+        )
+
+        with console.status(f"[bold green]Fetching result {result_id}..."):
+            response = result_retrieve.sync_detailed(client=client, id=result_id)
+
+        if response.status_code == 200 and response.parsed:
+            result = response.parsed
+            _display_result_details(result)
+
+        else:
+            raise click.ClickException(f"Result not found: {result_id}")
+
+    except Exception as e:
+        raise click.ClickException(f"Failed to fetch result: {e}")
+
+
+def _display_result_details(result) -> None:
+    """Display detailed information about a result"""
+
+    # Basic info table
+    table = Table(title="Result Details", show_header=True, header_style="bold cyan")
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("ID", str(result.id))
+
+    if hasattr(result, "agent_name"):
+        table.add_row("Agent", result.agent_name)
+
+    if hasattr(result, "attack_type"):
+        table.add_row("Attack Type", result.attack_type)
+
+    if hasattr(result, "evaluation_status"):
+        status = result.evaluation_status
+        if hasattr(status, "value"):
+            status = status.value
+        table.add_row("Status", str(status))
+
+    # Format dates
+    if hasattr(result, "created_at") and result.created_at:
+        try:
+            if isinstance(result.created_at, datetime):
+                created = result.created_at.strftime("%Y-%m-%d %H:%M:%S")
+            else:
+                created = str(result.created_at)
+        except (AttributeError, ValueError, TypeError):
+            created = str(result.created_at)
+        table.add_row("Created", created)
+
+    console.print(table)
+
+    # Show additional data if available
+    if hasattr(result, "data") and result.data:
+        console.print("\n[bold cyan]📋 Result Data:")
+        try:
+            import json
+
+            if isinstance(result.data, dict):
+                data_str = json.dumps(result.data, indent=2)
+            else:
+                data_str = str(result.data)
+            console.print(f"[dim]{data_str}")
+        except (json.JSONDecodeError, TypeError, AttributeError):
+            console.print(f"[dim]{result.data}")
+
+
+@results.command()
+@click.option(
+    "--status",
+    type=click.Choice(["pending", "running", "completed", "failed"]),
+    help="Filter by status",
+)
+@click.option("--agent", help="Filter by agent name")
+@click.option("--attack-type", help="Filter by attack type")
+@click.option("--days", default=7, help="Number of days to include (default: 7)")
+@click.pass_context
+@handle_errors
+def summary(ctx, status, agent, attack_type, days):
+    """Show summary statistics of attack results"""
+
+    cli_config: CLIConfig = ctx.obj["config"]
+    cli_config.validate()
+
+    try:
+        from hackagent.api.result import result_list
+        from hackagent.client import AuthenticatedClient
+
+        client = AuthenticatedClient(
+            base_url=cli_config.base_url, token=cli_config.api_key, prefix="Bearer"
+        )
+
+        # Fetch results (using a larger limit for statistics)
+        params = {"limit": 1000}
+        if status:
+            params["evaluation_status"] = status.upper()
+
+        with console.status("[bold green]Analyzing results..."):
+            response = result_list.sync_detailed(client=client, **params)
+
+        if response.status_code == 200 and response.parsed:
+            results_list = response.parsed.results
+
+            # Filter by date range
+            from datetime import datetime, timedelta
+
+            cutoff_date = datetime.now() - timedelta(days=days)
+
+            filtered_results = []
+            for result in results_list:
+                if hasattr(result, "created_at") and result.created_at:
+                    try:
+                        created_date = result.created_at
+                        if isinstance(created_date, str):
+                            created_date = datetime.fromisoformat(
+                                created_date.replace("Z", "+00:00")
+                            )
+                        if created_date >= cutoff_date:
+                            filtered_results.append(result)
+                    except (ValueError, TypeError, AttributeError):
+                        filtered_results.append(result)  # Include if date parsing fails
+
+            # Apply additional filters
+            if agent or attack_type:
+                temp_results = []
+                for result in filtered_results:
+                    if (
+                        agent
+                        and hasattr(result, "agent_name")
+                        and agent.lower() not in result.agent_name.lower()
+                    ):
+                        continue
+                    if (
+                        attack_type
+                        and hasattr(result, "attack_type")
+                        and attack_type.lower() not in result.attack_type.lower()
+                    ):
+                        continue
+                    temp_results.append(result)
+                filtered_results = temp_results
+
+            # Generate statistics
+            stats = _generate_result_statistics(filtered_results, days)
+            _display_result_summary(stats)
+
+        else:
+            raise click.ClickException(
+                f"Failed to fetch results: Status {response.status_code}"
+            )
+
+    except Exception as e:
+        raise click.ClickException(f"Failed to generate summary: {e}")
+
+
+def _generate_result_statistics(results, days: int) -> dict:
+    """Generate statistics from results list"""
+
+    total_results = len(results)
+
+    # Count by status
+    status_counts = {}
+    agent_counts = {}
+    attack_counts = {}
+
+    for result in results:
+        # Status statistics
+        if hasattr(result, "evaluation_status"):
+            status = result.evaluation_status
+            if hasattr(status, "value"):
+                status = status.value
+            else:
+                status = str(status)
+            status_counts[status] = status_counts.get(status, 0) + 1
+
+        # Agent statistics
+        if hasattr(result, "agent_name"):
+            agent = result.agent_name
+            agent_counts[agent] = agent_counts.get(agent, 0) + 1
+
+        # Attack type statistics
+        if hasattr(result, "attack_type"):
+            attack = result.attack_type
+            attack_counts[attack] = attack_counts.get(attack, 0) + 1
+
+    return {
+        "period_days": days,
+        "total_results": total_results,
+        "status_breakdown": status_counts,
+        "agent_breakdown": agent_counts,
+        "attack_type_breakdown": attack_counts,
+        "generated_at": str(datetime.now()),
+    }
+
+
+def _display_result_summary(stats: dict) -> None:
+    """Display result statistics summary"""
+
+    console.print(f"\n[bold cyan]📊 Results Summary (Last {stats['period_days']} days)")
+    console.print(f"[green]Total Results: {stats['total_results']}")
+
+    # Status breakdown
+    if stats["status_breakdown"]:
+        console.print("\n[bold cyan]📈 By Status:")
+        status_table = Table(show_header=True, header_style="bold cyan")
+        status_table.add_column("Status", style="cyan")
+        status_table.add_column("Count", style="green")
+        status_table.add_column("Percentage", style="yellow")
+
+        for status, count in stats["status_breakdown"].items():
+            percentage = (
+                (count / stats["total_results"]) * 100
+                if stats["total_results"] > 0
+                else 0
+            )
+            status_table.add_row(status, str(count), f"{percentage:.1f}%")
+
+        console.print(status_table)
+
+    # Top agents
+    if stats["agent_breakdown"]:
+        console.print("\n[bold cyan]🤖 By Agent:")
+        agent_table = Table(show_header=True, header_style="bold cyan")
+        agent_table.add_column("Agent", style="cyan")
+        agent_table.add_column("Count", style="green")
+
+        # Sort by count and show top 5
+        sorted_agents = sorted(
+            stats["agent_breakdown"].items(), key=lambda x: x[1], reverse=True
+        )
+        for agent, count in sorted_agents[:5]:
+            agent_table.add_row(agent, str(count))
+
+        console.print(agent_table)
+
+    # Attack types
+    if stats["attack_type_breakdown"]:
+        console.print("\n[bold cyan]🎯 By Attack Type:")
+        attack_table = Table(show_header=True, header_style="bold cyan")
+        attack_table.add_column("Attack Type", style="cyan")
+        attack_table.add_column("Count", style="green")
+
+        for attack_type, count in stats["attack_type_breakdown"].items():
+            attack_table.add_row(attack_type, str(count))
+
+        console.print(attack_table)