hackagent 0.3.1__py3-none-any.whl

hackagent/cli/tui/actions_logger.py

@@ -0,0 +1,200 @@
+# 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.
+
+"""
+TUI Actions Logger
+
+Custom logging handler that extracts and displays agent actions (tool calls, HTTP requests)
+in the TUI actions viewer.
+"""
+
+import logging
+import re
+from typing import Any, Callable
+
+
+class TUIActionsHandler(logging.Handler):
+    """
+    Custom logging handler that extracts agent actions from log messages
+    and displays them in the TUI actions viewer.
+
+    This handler parses log messages to identify:
+    - HTTP requests to agent endpoints
+    - Tool/function calls with arguments
+    - ADK agent events (tool_call, tool_result, llm_response)
+    - API responses
+    """
+
+    def __init__(
+        self,
+        actions_callback: Callable,
+        app_callback: Callable,
+        level: int = logging.INFO,
+    ):
+        """
+        Initialize the actions handler.
+
+        Args:
+            actions_callback: Callback function to add actions to the viewer
+                            Signature: (action_type: str, **kwargs)
+            app_callback: Callback to call actions from thread-safe context
+            level: Logging level
+        """
+        super().__init__(level)
+        self.actions_callback = actions_callback
+        self.app_callback = app_callback
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Process a log record and extract action information.
+
+        Args:
+            record: The log record to process
+        """
+        try:
+            message = record.getMessage()
+
+            # Pattern 1: HTTP requests to agent endpoints
+            # Example: "🌐 Sending request to agent endpoint: http://localhost:8000/run"
+            if "Sending request to agent endpoint:" in message or "🌐" in message:
+                url_match = re.search(r"(https?://[^\s]+)", message)
+                if url_match:
+                    url = url_match.group(1)
+                    method = "POST"  # Most agent requests are POST
+                    self.app_callback(
+                        self.actions_callback,
+                        "http_request",
+                        method=method,
+                        url=url,
+                    )
+
+            # Pattern 2: Tool calls (from _log_agent_actions in completions.py)
+            # Example: "🔧 Agent actions for prefix #1:"
+            elif "🔧 Agent actions" in message or "Tool:" in message:
+                # Extract tool name if present
+                tool_match = re.search(r"Tool:\s*(\w+)", message)
+                if tool_match:
+                    tool_name = tool_match.group(1)
+                    self.app_callback(
+                        self.actions_callback,
+                        "tool_call",
+                        tool_name=tool_name,
+                    )
+
+            # Pattern 3: ADK events
+            # Example: "🤖 ADK Agent actions for prefix #1:"
+            elif "🤖 ADK Agent actions" in message or "ADK" in message:
+                # Check subsequent messages for event details
+                if "Tool Call:" in message:
+                    tool_match = re.search(r"Tool Call:\s*(\w+)", message)
+                    if tool_match:
+                        tool_name = tool_match.group(1)
+                        self.app_callback(
+                            self.actions_callback,
+                            "adk_event",
+                            event_type="tool_call",
+                            tool_name=tool_name,
+                        )
+                elif "Tool Result:" in message:
+                    tool_match = re.search(r"Tool Result:\s*(\w+)", message)
+                    if tool_match:
+                        tool_name = tool_match.group(1)
+                        self.app_callback(
+                            self.actions_callback,
+                            "adk_event",
+                            event_type="tool_result",
+                            tool_name=tool_name,
+                        )
+                elif "LLM Response:" in message:
+                    content_match = re.search(r"LLM Response:\s*(.+)", message)
+                    content = content_match.group(1) if content_match else ""
+                    self.app_callback(
+                        self.actions_callback,
+                        "adk_event",
+                        event_type="llm_response",
+                        content=content,
+                    )
+
+            # Pattern 4: Agent responses
+            # Example: "✅ Agent responded with status 200"
+            elif "Agent responded" in message or "✅" in message:
+                status_match = re.search(r"status\s+(\d+)", message)
+                if status_match:
+                    # This indicates a successful HTTP response
+                    pass  # Could add response visualization here
+
+            # Pattern 5: Model queries (LiteLLM)
+            # Example: "🌐 Querying model gpt-4"
+            elif "Querying model" in message:
+                model_match = re.search(r"model\s+(\S+)", message)
+                if model_match:
+                    model_name = model_match.group(1)
+                    self.app_callback(
+                        self.actions_callback,
+                        "llm_query",
+                        model_name=model_name,
+                    )
+
+        except Exception:
+            # Silently fail to avoid breaking the logging system
+            pass
+
+
+def extract_action_data_from_log(
+    actions_viewer: Any,
+    action_type: str,
+    **kwargs: Any,
+) -> None:
+    """
+    Extract and display action data in the actions viewer.
+
+    Args:
+        actions_viewer: The AgentActionsViewer widget
+        action_type: Type of action (http_request, tool_call, adk_event, etc.)
+        **kwargs: Action-specific parameters
+    """
+    try:
+        if action_type == "http_request":
+            actions_viewer.add_http_request(
+                method=kwargs.get("method", "POST"),
+                url=kwargs.get("url", ""),
+                headers=kwargs.get("headers"),
+                payload=kwargs.get("payload"),
+            )
+
+        elif action_type == "tool_call":
+            actions_viewer.add_tool_call(
+                tool_name=kwargs.get("tool_name", "unknown"),
+                arguments=kwargs.get("arguments"),
+                result=kwargs.get("result"),
+            )
+
+        elif action_type == "adk_event":
+            event_type = kwargs.get("event_type", "unknown")
+            event_data = {
+                "tool_name": kwargs.get("tool_name", ""),
+                "tool_input": kwargs.get("tool_input", {}),
+                "result": kwargs.get("result", ""),
+                "content": kwargs.get("content", ""),
+            }
+            actions_viewer.add_adk_event(event_type, event_data)
+
+        elif action_type == "llm_query":
+            # Display LLM query as a special kind of action
+            model_name = kwargs.get("model_name", "unknown")
+            actions_viewer.add_step_separator(f"LLM Query: {model_name}")
+
+    except Exception:
+        # Silently fail to avoid breaking the UI
+        pass

hackagent/cli/tui/app.py

@@ -0,0 +1,288 @@
+# 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.
+
+"""
+Main TUI Application
+
+Full-screen tabbed interface for HackAgent.
+"""
+
+from typing import Any
+
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container
+from textual.widgets import Footer, Static, TabbedContent, TabPane
+
+from hackagent.cli.config import CLIConfig
+from hackagent.cli.tui.views.agents import AgentsTab
+from hackagent.cli.tui.views.attacks import AttacksTab
+from hackagent.cli.tui.views.config import ConfigTab
+from hackagent.cli.tui.views.results import ResultsTab
+
+
+class HackAgentHeader(Container):
+    """Custom header with ASCII logo"""
+
+    DEFAULT_CSS = """
+    HackAgentHeader {
+        dock: top;
+        width: 100%;
+        height: 7;
+        padding: 0 1;
+    }
+
+    HackAgentHeader Static {
+        color: #ff0000;
+        text-style: bold;
+        width: 100%;
+        content-align: center middle;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        from hackagent.utils import HACKAGENT
+
+        # Display the ASCII logo as-is (now side-by-side format)
+        logo_text = Text(HACKAGENT, style="bold red")
+        yield Static(logo_text)
+
+
+class HackAgentTUI(App):
+    """HackAgent Terminal User Interface Application"""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+
+    Header {
+        background: #8b0000;  /* dark red - HackAgent brand color */
+        color: #ffffff;
+        height: 3;
+    }
+
+    Footer {
+        background: #2b0000;  /* darker red */
+        color: #ffffff;
+    }
+
+    TabbedContent {
+        height: 100%;
+        border: solid #ff0000;  /* red - HackAgent brand color */
+    }
+
+    TabPane {
+        padding: 1 2;
+    }
+
+    TabbedContent > ContentSwitcher > * > * {
+        background: $surface;
+    }
+
+    Tabs {
+        background: #2b0000;
+    }
+
+    Tab {
+        color: #cccccc;
+        background: #2b0000;
+    }
+
+    Tab.-active {
+        color: #ffffff;
+        background: #8b0000;  /* dark red when active */
+        text-style: bold;
+    }
+
+    Tab:hover {
+        background: #5b0000;
+    }
+
+    .title-bar {
+        dock: top;
+        width: 100%;
+        background: #8b0000;
+        color: #ffffff;
+        height: 3;
+        content-align: center middle;
+    }
+
+    .section {
+        border: solid #ff0000;
+        padding: 1;
+        margin: 1;
+        height: auto;
+    }
+
+    .info-box {
+        background: $panel;
+        border: solid #ff0000;
+        padding: 1;
+        margin: 1;
+    }
+
+    Button {
+        margin: 1;
+    }
+
+    Button.-primary {
+        background: #8b0000;
+        color: #ffffff;
+    }
+
+    Button.-primary:hover {
+        background: #ff0000;
+    }
+
+    DataTable {
+        height: 100%;
+    }
+
+    DataTable > .datatable--header {
+        background: #8b0000;
+        color: #ffffff;
+        text-style: bold;
+    }
+
+    DataTable > .datatable--cursor {
+        background: #5b0000;
+    }
+
+    /* Results tab specific styles - horizontal split 20-80 */
+    ResultsTab #results-left-panel {
+        border-right: solid #ff0000;
+        background: $panel;
+    }
+
+    ResultsTab #results-right-panel {
+        background: $panel;
+    }
+
+    ResultsTab #results-title {
+        height: 3;
+        width: 100%;
+        text-align: center;
+        background: #8b0000;
+        color: #ffffff;
+        padding: 1;
+    }
+
+    ResultsTab #details-title {
+        height: 3;
+        width: 100%;
+        text-align: center;
+        background: #8b0000;
+        color: #ffffff;
+        padding: 1;
+    }
+
+    ResultsTab .toolbar {
+        height: 3;
+        width: 100%;
+        padding: 0 1;
+    }
+    """
+
+    TITLE = "🔴 HACKAGENT 🔴 - AI Security Testing Toolkit"
+    SUB_TITLE = "Red Team Security Interface"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", priority=True),
+        Binding("a", "switch_tab('agents')", "Agents", show=False),
+        Binding("k", "switch_tab('attacks')", "Attacks", show=False),
+        Binding("r", "switch_tab('results')", "Results", show=False),
+        Binding("c", "switch_tab('config')", "Config", show=False),
+        Binding("f5", "refresh", "Refresh", show=True),
+    ]
+
+    def __init__(
+        self,
+        cli_config: CLIConfig,
+        initial_tab: str = "agents",
+        initial_data: dict[Any, Any] | None = None,
+    ):
+        """Initialize the TUI application.
+
+        Args:
+            cli_config: CLI configuration object
+            initial_tab: Which tab to show initially (default: "agents")
+            initial_data: Initial data to pre-fill in the tab (default: None)
+        """
+        super().__init__()
+        self.cli_config = cli_config
+        self.initial_tab = initial_tab
+        self.initial_data = initial_data or {}
+        self.dark = True  # Use dark theme by default
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI layout."""
+        yield HackAgentHeader()
+
+        with TabbedContent(initial=self.initial_tab):
+            with TabPane("Agents", id="agents"):
+                yield AgentsTab(self.cli_config)
+
+            with TabPane("Attacks", id="attacks"):
+                yield AttacksTab(self.cli_config, initial_data=self.initial_data)
+
+            with TabPane("Results", id="results"):
+                yield ResultsTab(self.cli_config)
+
+            with TabPane("Config", id="config"):
+                yield ConfigTab(self.cli_config)
+
+        yield Footer()
+
+    def action_switch_tab(self, tab_id: str) -> None:
+        """Switch to a specific tab.
+
+        Args:
+            tab_id: ID of the tab to switch to
+        """
+        tabs = self.query_one(TabbedContent)
+        tabs.active = tab_id
+
+    def action_refresh(self) -> None:
+        """Refresh the current tab's data."""
+        tabs = self.query_one(TabbedContent)
+        active_pane = tabs.get_pane(tabs.active)
+        if active_pane and hasattr(active_pane, "refresh_data"):
+            # Get the first child of the TabPane (our custom tab widget)
+            for child in active_pane.children:
+                if hasattr(child, "refresh_data"):
+                    child.refresh_data()
+                    break
+
+    def on_mount(self) -> None:
+        """Called when the app is mounted."""
+        self.title = self.TITLE
+        self.sub_title = self.SUB_TITLE
+
+    def show_success(self, message: str) -> None:
+        """Show success notification with checkmark."""
+        pass
+
+    def show_error(self, message: str) -> None:
+        """Show error notification with X mark."""
+        pass
+
+    def show_warning(self, message: str) -> None:
+        """Show warning notification with warning sign."""
+        pass
+
+    def show_info(self, message: str) -> None:
+        """Show info notification with info icon."""
+        pass

hackagent/cli/tui/base.py

@@ -0,0 +1,137 @@
+# 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.
+
+"""
+Base Tab Class
+
+Base class for all TUI tabs with common functionality.
+"""
+
+import httpx
+from textual.containers import Container
+
+from hackagent.cli.config import CLIConfig
+from hackagent.client import AuthenticatedClient
+
+
+class BaseTab(Container):
+    """Base class for all TUI tabs.
+
+    Provides common functionality:
+    - CLI configuration access
+    - API client creation with timeout
+    - Error handling helpers
+    - Refresh mechanism
+
+    Subclasses should implement refresh_data() method.
+    """
+
+    # Default API timeout (can be overridden by subclasses)
+    API_TIMEOUT = 5.0
+
+    def __init__(self, cli_config: CLIConfig, **kwargs):
+        """Initialize base tab.
+
+        Args:
+            cli_config: CLI configuration instance
+            **kwargs: Additional arguments passed to Container
+        """
+        super().__init__(**kwargs)
+        self.cli_config = cli_config
+        self._refresh_interval = None
+
+    def create_api_client(self, timeout: float | None = None) -> AuthenticatedClient:
+        """Create an authenticated API client with timeout.
+
+        Args:
+            timeout: Optional timeout override (uses API_TIMEOUT by default)
+
+        Returns:
+            Configured AuthenticatedClient instance
+        """
+        if timeout is None:
+            timeout = self.API_TIMEOUT
+
+        return AuthenticatedClient(
+            base_url=self.cli_config.base_url,
+            token=self.cli_config.api_key,
+            prefix="Bearer",
+            timeout=httpx.Timeout(timeout, connect=timeout),
+        )
+
+    def handle_api_error(self, error: Exception, context: str = "API call") -> str:
+        """Format API error messages for display.
+
+        Args:
+            error: The exception that occurred
+            context: Description of what operation failed
+
+        Returns:
+            Formatted error message
+        """
+        from rich.markup import escape
+
+        if isinstance(error, httpx.TimeoutException):
+            return f"[red]Timeout:[/red] {context} took too long"
+        elif isinstance(error, httpx.HTTPStatusError):
+            if error.response.status_code == 401:
+                return (
+                    "[red]Authentication Failed[/red]\n\n"
+                    "[yellow]Your API key is invalid or expired[/yellow]\n\n"
+                    "[cyan]To fix:[/cyan]\n"
+                    "Run: hackagent config set --api-key YOUR_KEY\n\n"
+                    "[dim]Press F5 to retry after updating[/dim]"
+                )
+            else:
+                return f"[red]HTTP {error.response.status_code}:[/red] {context} failed"
+        else:
+            # Escape error message to prevent Rich markup issues
+            error_text = escape(str(error))
+            return f"[red]Error:[/red] {error_text}"
+
+    def refresh_data(self) -> None:
+        """Refresh tab data from API.
+
+        Should be overridden by subclasses that need data refresh functionality.
+        Default implementation does nothing.
+        """
+        pass
+
+    def enable_auto_refresh(self, interval: float = 5.0) -> None:
+        """Enable automatic data refresh at specified interval.
+
+        Args:
+            interval: Refresh interval in seconds (default: 5.0)
+        """
+        if self._refresh_interval is not None:
+            # Remove existing refresh timer
+            self._refresh_interval = None
+
+        self._refresh_interval = self.set_interval(
+            interval, self.refresh_data, name=f"{self.__class__.__name__}-refresh"
+        )
+
+    def disable_auto_refresh(self) -> None:
+        """Disable automatic data refresh."""
+        if self._refresh_interval is not None:
+            self._refresh_interval = None
+
+    def on_mount(self) -> None:
+        """Called when tab is mounted.
+
+        Subclasses can override to add custom mounting behavior,
+        but should call super().on_mount() to ensure proper initialization.
+        """
+        # Defer initial load to ensure DOM is ready
+        self.call_after_refresh(self.refresh_data)