praetorian-cli 2.2.4__py3-none-any.whl → 2.2.5__py3-none-any.whl

praetorian_cli/handlers/add.py

@@ -5,7 +5,7 @@ import click
 
 from praetorian_cli.handlers.chariot import chariot
 from praetorian_cli.handlers.cli_decorators import cli_handler, praetorian_only
-from praetorian_cli.handlers.utils import error
+from praetorian_cli.handlers.utils import error, parse_configuration_value
 from praetorian_cli.sdk.model.globals import AddRisk, Asset, Seed, Kind
 
 
@@ -274,40 +274,33 @@ def setting(sdk, name, value):
 @add.command()
 @cli_handler
 @click.option('-n', '--name', required=True, help='Name of the configuration')
-@click.option('-e', '--entry', required=True, multiple=True, help='Key-value pair in format key=value. Can be specified multiple times to set multiple values.')
+@click.option('-e', '--entry', required=False, multiple=True,
+              help='Key-value pair in format key=value. Can be specified multiple times to set multiple values.')
+@click.option('--string', 'string_value', required=False,
+              help='Set the configuration value to a string')
+@click.option('--integer', 'integer_value', required=False,
+              help='Set the configuration value to an integer')
+@click.option('--float', 'float_value', required=False,
+              help='Set the configuration value to a floating point number')
 @praetorian_only
-def configuration(sdk, name, entry):
+def configuration(sdk, name, entry, string_value, integer_value, float_value):
     """ Add a configuration
 
-    This command adds, or overwrites if exists, a name-value configuration.
+    This command adds, or overwrites if exists, a configuration value.
+
+    Configuration values can be provided as a mapping of key-value pairs using
+    ``--entry`` (the previous behavior), or as primitive values using
+    ``--string``, ``--integer``, or ``--float``.
 
     \b
     Example usages:
         - praetorian chariot add configuration --name "nuclei" --entry extra-tags=http,sql --entry something=else
+        - praetorian chariot add configuration --name "billing-status" --string PAID_MS
+        - praetorian chariot add configuration --name "request-timeout" --integer 60
+        - praetorian chariot add configuration --name "scoring-threshold" --float 0.85
     """
-    config_dict = {}
-    for item in entry:
-        if '=' not in item:
-            click.echo(f"Error: Entry '{item}' is not in the format key=value")
-            return
-
-        if item.count('=') > 1:
-            click.echo(f"Error: Entry '{item}' contains multiple '=' characters. Format should be key=value")
-            return
-
-        key, value = item.split('=', 1)
-
-        if not key:
-            click.echo("Error: Key cannot be empty")
-            return
-
-        if not value:
-            click.echo("Error: Value cannot be empty")
-            return
-
-        config_dict[key] = value
-
-    sdk.configurations.add(name, config_dict)
+    config_value = parse_configuration_value(entry, string_value, integer_value, float_value)
+    sdk.configurations.add(name, config_value)
 
 
 @add.command()

praetorian_cli/handlers/agent.py

@@ -69,3 +69,32 @@ def tools(sdk, allowed):
     """
     for  tool in dict.keys(sdk.agents.list_mcp_tools(allowed)):
         click.echo(tool)
+
+@agent.command()
+@cli_handler
+def conversation(sdk):
+    """ Interactive conversation with Chariot AI assistant
+    
+    Start an interactive chat session with the Chariot AI assistant.
+    The AI can help you query security data, understand findings,
+    and provide insights about your attack surface.
+    
+    \b
+    Commands within conversation:
+        - help    Show available commands and query examples
+        - clear   Clear the screen  
+        - new     Start a new conversation
+        - quit    Exit the conversation
+    
+    \b
+    Example queries:
+        - "Find all active assets"
+        - "Show me critical risks"
+        - "What assets do we have for example.com?"
+        
+    \b
+    Usage:
+        praetorian chariot agent conversation
+    """
+    from praetorian_cli.ui.conversation import run_textual_conversation
+    run_textual_conversation(sdk)

praetorian_cli/handlers/get.py

@@ -147,7 +147,8 @@ def file(chariot, name, path):
 @cli_handler
 @click.argument('name')
 @click.option('-path', '--path', default=os.getcwd(), help='Download path. Default: save to current directory')
-def definition(chariot, name, path):
+@click.option('--global', 'global_', is_flag=True, help='Fetch from global definitions instead of user-specific')
+def definition(chariot, name, path, global_):
     """ Download a definition using the risk name
 
     \b
@@ -158,8 +159,9 @@ def definition(chariot, name, path):
     Example usage:
         - praetorian chariot get definition jira-unauthenticated-user-picker
         - praetorian chariot get definition CVE-2024-23049
+        - praetorian chariot get definition CVE-2024-23049 --global
      """
-    downloaded_path = chariot.definitions.get(name, path)
+    downloaded_path = chariot.definitions.get(name, path, global_=global_)
     click.echo(f'Saved definition at {downloaded_path}')
 
 

praetorian_cli/handlers/utils.py

@@ -3,6 +3,65 @@ import json
 import click
 
 
+def parse_configuration_value(
+    entries = [], s_val=None, i_val=None, f_val=None):
+    """Return a configuration value derived from CLI inputs."""
+    has_entries = len(entries) > 0
+    typed_values = {
+        'string': s_val,
+        'integer': i_val,
+        'float': f_val,
+    }
+
+    if has_entries and any(value is not None for value in typed_values.values()):
+        error('--entry cannot be combined with --string, --integer, or --float')
+
+    if has_entries:
+        return _parse_entry_dict(entries)
+
+    provided = [(name, value) for name, value in typed_values.items() if value is not None]
+
+    if not provided:
+        error('Provide configuration data via --entry, --string, --integer, or --float')
+    if len(provided) > 1:
+        error('Specify only one of --string, --integer, or --float')
+
+    value_type, raw_value = provided[0]
+    return _cast_typed_value(value_type, raw_value)
+
+
+def _parse_entry_dict(entries):
+    parsed = {}
+
+    for item in entries:
+        key, value = _split_entry(item)
+        if not key:
+            error(f'Key cannot be empty: {item}')
+        if not value:
+            error(f'Value cannot be empty: {item}')
+        parsed[key] = value
+    return parsed
+
+
+def _split_entry(item):
+    if '=' not in item:
+        error(f"Entry '{item}' is not in the format key=value")
+    if item.count('=') > 1:
+        error(f"Entry '{item}' contains multiple '=' characters. Format should be key=value")
+    return item.split('=', 1)
+
+
+def _cast_typed_value(value_type, raw_value):
+    try:
+        if value_type == 'integer':
+            return int(raw_value)
+        if value_type == 'float':
+            return float(raw_value)
+    except ValueError:
+        error(f'{value_type} must be a valid {value_type}')
+    return raw_value
+
+
 def render_list_results(list_results, details):
     list_data, offset = list_results
     if details:

praetorian_cli/sdk/entities/configurations.py

@@ -27,7 +27,7 @@ class Configurations:
                 "Please contact your Praetorian representative for assistance."
             )
 
-    def add(self, name, value: dict):
+    def add(self, name, value):
         """
         Add or update a configuration.
 

praetorian_cli/sdk/entities/definitions.py

@@ -29,7 +29,7 @@ class Definitions:
             definition_name = os.path.basename(local_filepath)
         return self.api.files.add(local_filepath, f'definitions/{definition_name}')
 
-    def get(self, definition_name, download_directory=os.getcwd()):
+    def get(self, definition_name, download_directory=os.getcwd(), global_=False):
         """
         Download a risk definition file from the definitions folder.
 
@@ -37,15 +37,24 @@ class Definitions:
         :type definition_name: str
         :param download_directory: The directory to save the downloaded file (defaults to current working directory)
         :type download_directory: str
+        :param global_: If True, fetch from global definitions instead of user-specific
+        :type global_: bool
         :return: The local file path where the definition was saved
         :rtype: str
         """
-        content = self.api.files.get_utf8(f'definitions/{definition_name}')
+        try:
+            content = self.api.files.get_utf8(f'definitions/{definition_name}', _global=global_)
+        except Exception as e:
+            if global_:
+                raise Exception(f'Global definition {definition_name} not found or inaccessible.')
+            else:
+                raise
         download_path = os.path.join(download_directory, definition_name)
         with open(download_path, 'w') as file:
             file.write(content)
         return download_path
 
+
     def list(self, name_filter='', offset=None, pages=100000) -> tuple:
         """
         List the definition names, optionally prefix-filtered by a definition name.

praetorian_cli/sdk/entities/files.py

@@ -46,30 +46,35 @@ class Files:
 
         return download_path
 
-    def get(self, chariot_filepath) -> bytes:
+    def get(self, chariot_filepath, _global=False) -> bytes:
         """
         Download a file from Chariot storage into memory as bytes.
 
         :param chariot_filepath: Path of the file in Chariot storage to download
         :type chariot_filepath: str
+        :param _global: If True, fetch from global storage instead of user-specific
+        :type _global: bool
         :return: The file content as bytes
         :rtype: bytes
         :raises Exception: If the file does not exist in Chariot storage
         """
-        self.raise_if_missing(chariot_filepath)
-        return self.api.download(chariot_filepath)
+        if not _global:
+            self.raise_if_missing(chariot_filepath)
+        return self.api.download(chariot_filepath, global_=_global)
 
-    def get_utf8(self, chariot_filepath) -> str:
+    def get_utf8(self, chariot_filepath, _global=False) -> str:
         """
         Download a file from Chariot storage into memory as a UTF-8 string.
 
         :param chariot_filepath: Path of the file in Chariot storage to download
         :type chariot_filepath: str
+        :param _global: If True, fetch from global storage instead of user-specific
+        :type _global: bool
         :return: The file content as a UTF-8 decoded string
         :rtype: str
         :raises Exception: If the file does not exist in Chariot storage
         """
-        return self.get(chariot_filepath).decode('utf-8')
+        return self.get(chariot_filepath, _global=_global).decode('utf-8')
 
     def list(self, prefix_filter='', offset=None, pages=100000) -> tuple:
         """

praetorian_cli/sdk/entities/search.py

@@ -1,6 +1,6 @@
 import json
 from praetorian_cli.sdk.model.query import Query
-from praetorian_cli.sdk.model.globals import EXACT_FLAG, DESCENDING_FLAG, GLOBAL_FLAG, Kind
+from praetorian_cli.sdk.model.globals import EXACT_FLAG, DESCENDING_FLAG, GLOBAL_FLAG, USER_FLAG, Kind
 class Search:
 
     def __init__(self, api):
@@ -17,7 +17,7 @@ class Search:
         """
         return self.api.count(dict(key=search_term))
 
-    def by_key_prefix(self, key_prefix, offset=None, pages=100000) -> tuple:
+    def by_key_prefix(self, key_prefix, offset=None, pages=100000, user=False) -> tuple:
         """
         Search for entities by key prefix. <mcp>If the response is too large, make your query more specific.<mcp>
 
@@ -30,7 +30,7 @@ class Search:
         :return: A tuple containing (list of matching entities, next page offset)
         :rtype: tuple
         """
-        return self.by_term(key_prefix, None, offset, pages)
+        return self.by_term(key_prefix, None, offset, pages, user=user)
 
     def by_exact_key(self, key, get_attributes=False) -> {}:
         """
@@ -119,7 +119,7 @@ class Search:
         return self.by_term(f'dns:{dns_prefix}', kind, offset, pages)
 
     def by_term(self, search_term, kind=None, offset=None, pages=100000, exact=False, descending=False,
-                global_=False) -> tuple:
+                global_=False, user=False) -> tuple:
         """
         Search for a given kind by term.
 
@@ -151,6 +151,8 @@ class Search:
             params |= DESCENDING_FLAG
         if global_:
             params |= GLOBAL_FLAG
+        if user:
+            params |= USER_FLAG
 
         results = self.api.my(params, pages)
 

praetorian_cli/sdk/model/globals.py

@@ -114,3 +114,4 @@ class Kind(Enum):
 EXACT_FLAG = {'exact': 'true'}
 DESCENDING_FLAG = {'desc': 'true'}
 GLOBAL_FLAG = {'global': 'true'}
+USER_FLAG = {'user': 'true'}

praetorian_cli/sdk/test/test_conversation.py

@@ -0,0 +1,195 @@
+import pytest
+import json
+import time
+
+from praetorian_cli.sdk.test.utils import make_test_values, clean_test_entities, setup_chariot
+
+
+@pytest.mark.coherence
+class TestConversation:
+    """Test conversation functionality with the Chariot agent"""
+
+    def setup_class(self):
+        self.sdk = setup_chariot()
+        make_test_values(self)
+        self.conversation_id = None
+        self.message_keys = []
+
+    def test_start_conversation(self):
+        """Test starting a new conversation with the agent"""
+        url = self.sdk.url("/planner")
+        payload = {
+            "message": f"Test conversation started at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=payload)
+        
+        # Should get successful response
+        assert response.status_code == 200
+        
+        result = response.json()
+        assert "conversation" in result
+        assert "uuid" in result["conversation"]
+        
+        self.conversation_id = result["conversation"]["uuid"]
+        assert self.conversation_id is not None
+        assert len(self.conversation_id) > 0
+
+    def test_send_message_with_existing_conversation(self):
+        """Test sending a message to an existing conversation"""
+        # First, start a new conversation
+        url = self.sdk.url("/planner")
+        initial_payload = {
+            "message": f"Initial message for follow-up test at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=initial_payload)
+        assert response.status_code == 200
+        
+        result = response.json()
+        conversation_id = result["conversation"]["uuid"]
+        
+        # Now send a follow-up message to the existing conversation
+        follow_up_payload = {
+            "message": f"Follow-up message in existing conversation at {int(time.time())}",
+            "mode": "query",
+            "conversationId": conversation_id
+        }
+        
+        response = self.sdk._make_request("POST", url, json=follow_up_payload)
+        
+        # Should get successful response
+        assert response.status_code == 200
+
+    def test_read_conversation_messages(self):
+        """Test reading messages from a conversation"""
+        # First, create a conversation and send a message
+        url = self.sdk.url("/planner")
+        payload = {
+            "message": f"Test message for reading at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=payload)
+        assert response.status_code == 200
+        
+        result = response.json()
+        conversation_id = result["conversation"]["uuid"]
+        
+        # Wait a moment for message to be stored
+        time.sleep(2)
+        
+        # Now try to read messages from this conversation
+        messages, offset = self.sdk.search.by_key_prefix(
+            f"#message#{conversation_id}#", user=True
+        )
+        
+        # Should have at least the user message
+        assert isinstance(messages, list)
+        # Note: messages might be empty immediately after creation due to async processing
+        # This is still a valid test as it verifies the search functionality works
+
+    def test_read_conversations_list(self):
+        """Test reading list of conversations"""
+        # First create a test conversation
+        url = self.sdk.url("/planner")
+        payload = {
+            "message": f"Test conversation for listing at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=payload)
+        assert response.status_code == 200
+        
+        # Wait a moment for conversation to be stored
+        time.sleep(1)
+        
+        # Now search for conversations
+        conversations, offset = self.sdk.search.by_key_prefix(
+            "#conversation#", user=True
+        )
+        
+        # Should be able to search for conversations (list might be empty or contain conversations)
+        assert isinstance(conversations, list)
+
+    def test_conversation_api_error_handling(self):
+        """Test handling of malformed requests"""
+        url = self.sdk.url("/planner")
+        # Send malformed payload (missing required fields)
+        malformed_payload = {
+            "invalid_field": "should cause error"
+            # Missing required "message" field
+        }
+        
+        response = self.sdk._make_request("POST", url, json=malformed_payload)
+        
+        # Should get a 4xx error for bad request
+        assert response.status_code >= 400
+
+    def test_conversation_modes(self):
+        """Test different conversation modes (query vs agent)"""
+        url = self.sdk.url("/planner")
+        
+        # Test query mode
+        query_payload = {
+            "message": f"Test query mode at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=query_payload)
+        assert response.status_code == 200
+        
+        result = response.json()
+        assert "conversation" in result
+        
+        # Test agent mode
+        agent_payload = {
+            "message": f"Test agent mode at {int(time.time())}",
+            "mode": "agent"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=agent_payload)
+        assert response.status_code == 200
+        
+        result = response.json()
+        assert "conversation" in result
+
+    def test_message_polling_integration(self):
+        """Test integration of message polling to check for new messages"""
+        # Create a conversation first
+        url = self.sdk.url("/planner")
+        payload = {
+            "message": f"Test message for polling at {int(time.time())}",
+            "mode": "query"
+        }
+        
+        response = self.sdk._make_request("POST", url, json=payload)
+        assert response.status_code == 200
+        
+        result = response.json()
+        conversation_id = result["conversation"]["uuid"]
+        
+        # Test polling for messages (first call)
+        messages, offset = self.sdk.search.by_key_prefix(
+            f"#message#{conversation_id}#", user=True
+        )
+        
+        initial_count = len(messages) if messages else 0
+        
+        # Wait a moment and check again (simulating polling)
+        time.sleep(1)
+        
+        messages, offset = self.sdk.search.by_key_prefix(
+            f"#message#{conversation_id}#", user=True
+        )
+        
+        # Should still return valid result (messages may or may not have changed)
+        assert isinstance(messages, list)
+
+    def teardown_class(self):
+        """Clean up test data"""
+        # Note: Conversations and messages are typically read-only in tests
+        # Real cleanup would depend on having delete methods for conversations
+        pass

praetorian_cli/sdk/test/test_z_cli.py

@@ -5,6 +5,7 @@ from subprocess import run
 import pytest
 
 from praetorian_cli.sdk.model.globals import AddRisk, Asset, Risk, Seed, Preseed
+from praetorian_cli.sdk.model.utils import configuration_key
 from praetorian_cli.sdk.test.utils import epoch_micro, random_ip, make_test_values, clean_test_entities, setup_chariot
 
 
@@ -273,6 +274,24 @@ class TestZCli:
 
         self.verify(f'delete configuration "{o.configuration_key}"', ignore_stdout=True)
 
+        string_name = f'{o.configuration_name}-string'
+        string_key = configuration_key(string_name)
+        self.verify(f'add configuration --name "{string_name}" --string PAID_MS')
+        self.verify(f'get configuration "{string_key}"', expected_stdout=[string_key, string_name, '"value": "PAID_MS"'])
+        self.verify(f'delete configuration "{string_key}"', ignore_stdout=True)
+
+        integer_name = f'{o.configuration_name}-integer'
+        integer_key = configuration_key(integer_name)
+        self.verify(f'add configuration --name "{integer_name}" --integer 123')
+        self.verify(f'get configuration "{integer_key}"', expected_stdout=[integer_key, integer_name, '"value": 123'])
+        self.verify(f'delete configuration "{integer_key}"', ignore_stdout=True)
+
+        float_name = f'{o.configuration_name}-float'
+        float_key = configuration_key(float_name)
+        self.verify(f'add configuration --name "{float_name}" --float 1.5')
+        self.verify(f'get configuration "{float_key}"', expected_stdout=[float_key, float_name, '"value": 1.5'])
+        self.verify(f'delete configuration "{float_key}"', ignore_stdout=True)
+
     def test_webapplication_cli(self):
         o = make_test_values(lambda: None)
         self.verify(f'add asset --dns "{o.webapp_name}" --name "{o.webapp_url}" --type webapplication')
@@ -339,6 +358,11 @@ class TestZCli:
 
         self.verify('link --help', ignore_stdout=True)
         self.verify('link account --help', ignore_stdout=True)
+        
+        # Agent commands
+        self.verify('agent --help', ignore_stdout=True)
+        self.verify('agent conversation --help', ignore_stdout=True)
+        self.verify('agent mcp --help', ignore_stdout=True)
         self.verify('link webpage-source --help', ignore_stdout=True)
 
         self.verify('unlink --help', ignore_stdout=True)

praetorian_cli/ui/conversation/__init__.py

@@ -0,0 +1,3 @@
+from .textual_chat import run_textual_conversation
+
+__all__ = ['run_textual_conversation']

praetorian_cli/ui/conversation/textual_chat.py

@@ -0,0 +1,622 @@
+#!/usr/bin/env python3
+
+import asyncio
+import json
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Vertical, Horizontal, VerticalScroll
+from textual.widgets import Header, Footer, Input, Static, Markdown
+from textual.message import Message
+from textual.reactive import reactive
+from textual import on
+
+from praetorian_cli.sdk.chariot import Chariot
+
+
+class ChatMessage(Static):
+    """A single chat message widget"""
+    
+    def __init__(self, role: str, content: str, **kwargs):
+        self.role = role
+        self.content = content
+        super().__init__(**kwargs)
+    
+    def compose(self) -> ComposeResult:
+        if self.role == "user":
+            yield Static(f"👤 You: {self.content}", classes="user-message")
+        elif self.role == "chariot":
+            yield Markdown(self.content, classes="ai-message")
+        elif self.role == "tool call":
+            yield Static("🔧 Executing tool...", classes="tool-message")
+        elif self.role == "tool response":
+            yield Static("✅ Tool execution completed", classes="tool-message")
+        elif self.role == "planner-output":
+            yield Static("🎯 Processing job completion...", classes="system-message")
+
+
+class ConversationApp(App):
+    """Textual-based conversation interface with separate chat log and input"""
+    
+    CSS = """
+    Screen {
+        layout: vertical;
+        background: #0d0d28;
+    }
+    
+    #chat-container {
+        height: 1fr;
+        border: solid #323452;
+        margin: 1;
+        background: #0d0d28;
+    }
+    
+    #input-container {
+        height: 7;
+        border: solid #5f47b7;
+        margin: 0 1 0 1;
+        background: #28205a;
+    }
+    
+    .user-message {
+        background: #28205a;
+        color: #afa3db;
+        padding: 1;
+        margin: 0 0 1 0;
+        border-left: thick #5f47b7;
+    }
+    
+    .ai-message {
+        background: #3d3d53;
+        color: #ece6fc;
+        padding: 1;
+        margin: 0 0 1 0;
+        border-left: thick #5f47b7;
+    }
+    
+    .tool-message {
+        color: #afa3db;
+        padding: 0 1;
+        text-style: italic;
+        background: #323452;
+    }
+    
+    .system-message {
+        color: #ece6fc;
+        padding: 0 1;
+        text-style: italic;
+        background: #25253e;
+    }
+    
+    Input {
+        height: 3;
+        margin: 1 1;
+        background: #0d0d28;
+        color: #ece6fc;
+        border: solid #323452;
+    }
+    
+    #status-bar {
+        height: 1;
+        background: #323452;
+        color: #afa3db;
+        padding: 0 1;
+    }
+    
+    Header {
+        background: #0d0d28;
+        color: #ece6fc;
+    }
+    
+    Footer {
+        background: #323452;
+        color: #afa3db;
+    }
+    """
+    
+    TITLE = "Chariot AI Assistant"
+    
+    # Reactive attributes
+    conversation_id: reactive[Optional[str]] = reactive(None)
+    last_message_key: reactive[str] = reactive("")
+    mode: reactive[str] = reactive("query")
+    
+    def __init__(self, sdk: Chariot):
+        super().__init__()
+        self.sdk = sdk
+        self.user_email, self.username = self.sdk.get_current_user()
+        self.polling_task: Optional[asyncio.Task] = None
+        self._selecting_conversation = False
+        self._available_conversations = []
+        
+    def compose(self) -> ComposeResult:
+        """Compose the UI layout"""
+        yield Header()
+        
+        # Main chat area with scrolling
+        with Container(id="chat-container"):
+            yield VerticalScroll(id="chat-log")
+        
+        # Status bar showing conversation info
+        yield Static(f"User: {self.username} | Mode: {self.mode} | Ready", id="status-bar")
+        
+        # Input area at bottom
+        with Container(id="input-container"):
+            yield Input(placeholder="Type your message here... (type 'help' for commands)", id="message-input")
+        
+        yield Footer()
+    
+    def on_mount(self) -> None:
+        """Called when app starts"""
+        # Start background polling for job completion events
+        self.polling_task = asyncio.create_task(self.background_poll())
+        
+        # Focus the input
+        self.query_one("#message-input").focus()
+        
+        # Show welcome message
+        self.add_system_message("Welcome to Chariot AI Assistant! Type 'help' for commands or ask about your security data.")
+    
+    @on(Input.Submitted, "#message-input")
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle user input submission"""
+        message = event.value.strip()
+        if not message:
+            return
+            
+        # Clear the input
+        input_widget = self.query_one("#message-input")
+        input_widget.clear()
+        
+        # Handle special commands
+        if message.lower() in ['quit', 'exit', 'q']:
+            self.exit()
+            return
+        elif message.lower() in ['clear', 'cls']:
+            await self.clear_chat()
+            return
+        elif message.lower() == 'help':
+            self.show_help()
+            return
+        elif message.lower() in ['new']:
+            await self.start_new_conversation()
+            return
+        elif message.lower() in ['resume']:
+            await self.resume_conversation()
+            return
+        elif message.lower() in ['mode query', 'query']:
+            self.set_mode('query')
+            return
+        elif message.lower() in ['mode agent', 'agent']:
+            self.set_mode('agent')
+            return
+        elif message.lower() == 'jobs':
+            await self.show_job_status()
+            return
+        
+        # Handle conversation selection
+        if self._selecting_conversation:
+            await self.handle_conversation_selection(message)
+            return
+        
+        # Send user message
+        await self.send_message(message)
+    
+    async def send_message(self, message: str) -> None:
+        """Send user message and wait for AI response"""
+        try:
+            # Display user message immediately for instant feedback
+            self.add_user_message(message)
+            self.update_status("Sending message...")
+            
+            # Create async task for API call to avoid blocking UI
+            async def send_api_request():
+                try:
+                    # Call API in background
+                    response = self.call_conversation_api(message)
+                    
+                    if response.get('error'):
+                        self.add_system_message(f"Error: {response.get('error')}")
+                        self.update_status("Error - Ready for next message")
+                        return
+                    
+                    # Update status and wait for AI response
+                    self.update_status("Waiting for AI response...")
+                    
+                    # Poll for AI response
+                    await self.wait_for_ai_response()
+                    
+                except Exception as e:
+                    self.add_system_message(f"Failed to send message: {e}")
+                    self.update_status("Error - Ready for next message")
+            
+            # Start the API request as a background task
+            asyncio.create_task(send_api_request())
+            
+        except Exception as e:
+            self.add_system_message(f"Failed to send message: {e}")
+            self.update_status("Error - Ready for next message")
+    
+    async def wait_for_ai_response(self) -> None:
+        """Wait for AI response and display it"""
+        while True:
+            # Check for new messages
+            await self.check_for_new_messages()
+            
+            # Check if we got an AI response
+            chat_log = self.query_one("#chat-log")
+            if chat_log.children and hasattr(chat_log.children[-1], 'role'):
+                last_widget = chat_log.children[-1]
+                if hasattr(last_widget, 'role') and last_widget.role == "chariot":
+                    self.update_status("Ready")
+                    break
+            
+            await asyncio.sleep(1)
+    
+    async def background_poll(self) -> None:
+        """Background polling for job completion events"""
+        while True:
+            try:
+                if self.conversation_id:
+                    await self.check_for_new_messages()
+                await asyncio.sleep(3)  # Poll every 3 seconds
+            except Exception:
+                pass
+    
+    async def check_for_new_messages(self) -> None:
+        """Check for new messages and display them"""
+        if not self.conversation_id:
+            return
+            
+        try:
+            # Load all messages for this conversation
+            all_messages, _ = self.sdk.search.by_key_prefix(f"#message#{self.conversation_id}#", user=True)
+            
+            # Filter to only new messages
+            if self.last_message_key:
+                messages = [msg for msg in all_messages if msg.get('key', '') > self.last_message_key]
+            else:
+                messages = all_messages
+            
+            if messages:
+                messages = sorted(messages, key=lambda x: x.get('key', ''))
+                
+                for msg in messages:
+                    role = msg.get('role')
+                    content = msg.get('content', '')
+                    
+                    if role == 'chariot':
+                        self.add_ai_message(content)
+                    elif role == 'tool call':
+                        self.add_tool_message("🔧 Executing tool...")
+                        self.update_status("Executing tool...")
+                    elif role == 'tool response':
+                        self.add_tool_message("✅ Tool execution completed")
+                        self.update_status("Tool completed, thinking...")
+                    elif role == 'planner-output':
+                        self.add_system_message("🎯 Processing job completion...")
+                
+                # Update last message key
+                self.last_message_key = messages[-1].get('key', '')
+                
+        except Exception as e:
+            pass
+    
+    def add_user_message(self, content: str) -> None:
+        """Add user message to chat log"""
+        chat_log = self.query_one("#chat-log")
+        message_widget = Static(f"👤 You: {content}", classes="user-message")
+        chat_log.mount(message_widget)
+        chat_log.scroll_end()
+    
+    def add_ai_message(self, content: str) -> None:
+        """Add AI message to chat log"""
+        chat_log = self.query_one("#chat-log")
+        message_widget = Markdown(content, classes="ai-message")
+        message_widget.role = "chariot"  # Add role attribute for tracking
+        chat_log.mount(message_widget)
+        chat_log.scroll_end()
+    
+    def add_tool_message(self, content: str) -> None:
+        """Add tool execution message to chat log"""
+        chat_log = self.query_one("#chat-log")
+        message_widget = Static(content, classes="tool-message")
+        chat_log.mount(message_widget)
+        chat_log.scroll_end()
+    
+    def add_system_message(self, content: str) -> None:
+        """Add system message to chat log"""
+        chat_log = self.query_one("#chat-log")
+        message_widget = Static(content, classes="system-message")
+        chat_log.mount(message_widget)
+        chat_log.scroll_end()
+    
+    def update_status(self, status: str) -> None:
+        """Update status bar"""
+        status_bar = self.query_one("#status-bar")
+        conv_info = f"Conversation: {self.conversation_id[:8]}..." if self.conversation_id else "No conversation"
+        status_bar.update(f"User: {self.username} | Mode: {self.mode} | {conv_info} | {status}")
+    
+    def call_conversation_api(self, message: str) -> Dict:
+        """Call the Chariot conversation API"""
+        url = self.sdk.url("/planner")
+        payload = {"message": message, "mode": self.mode}
+        
+        if self.conversation_id:
+            payload["conversationId"] = self.conversation_id
+        
+        response = self.sdk._make_request("POST", url, json=payload)
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            if not self.conversation_id and 'conversation' in result:
+                self.conversation_id = result['conversation'].get('uuid')
+                self.update_status("Ready")
+            
+            return {'success': True}
+        else:
+            return {
+                'success': False,
+                'error': f"API error: {response.status_code} - {response.text}"
+            }
+    
+    def show_help(self) -> None:
+        """Show help information"""
+        help_text = """
+# Available Commands:
+- `help` - Show this help
+- `clear` - Clear chat log
+- `new` - Start new conversation
+- `resume` - Resume existing conversation
+- `query` - Switch to Query Mode (data discovery only)
+- `agent` - Switch to Agent Mode (full security operations)
+- `jobs` - Show running jobs
+- `quit` - Exit
+
+# Query Mode:
+- Search and analyze existing security data
+- List available capabilities
+- Data discovery focus
+
+# Agent Mode:
+- Full security operations
+- Execute scans and manage assets
+- Comprehensive attack surface management
+
+# Examples:
+- "Find all active assets"
+- "Show me high-priority risks" 
+- "Run a port scan on 10.0.1.5" (agent mode only)
+        """
+        self.add_system_message(help_text)
+    
+    def set_mode(self, mode: str) -> None:
+        """Switch conversation mode"""
+        if mode in ["query", "agent"]:
+            self.mode = mode
+            self.update_status("Ready")
+            if mode == "query":
+                self.add_system_message("Switched to Query Mode - Data discovery and analysis focus")
+            elif mode == "agent":
+                self.add_system_message("Switched to Agent Mode - Full security operations")
+        else:
+            self.add_system_message(f"Invalid mode: {mode}. Available modes: query, agent")
+    
+    async def start_new_conversation(self) -> None:
+        """Start a new conversation"""
+        self.conversation_id = None
+        self.last_message_key = ""
+        await self.clear_chat()
+        self.add_system_message("Started new conversation")
+        self.update_status("Ready")
+    
+    async def resume_conversation(self) -> None:
+        """Resume an existing conversation"""
+        try:
+            # Get recent conversations
+            conversations, _ = self.sdk.search.by_key_prefix("#conversation#", user=True)
+            conversations = sorted(conversations, key=lambda x: x.get('created', ''), reverse=True)
+            
+            if not conversations:
+                self.add_system_message("No recent conversations found. Starting new conversation.")
+                await self.start_new_conversation()
+                return
+            
+            # Show beautiful conversations table
+            conv_list = f"""
+# 💬 Resume Conversation
+
+**Found {len(conversations)} recent conversations**
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                      RECENT CONVERSATIONS                       │
+├─────────────────────────────────────────────────────────────────┤
+"""
+            
+            for i, conv in enumerate(conversations[:10]):
+                topic = conv.get('topic', 'No topic')
+                # Truncate topic but show more characters
+                if len(topic) > 45:
+                    topic = topic[:42] + "..."
+                
+                created = conv.get('created', 'Unknown')
+                # Format date more nicely
+                if created != 'Unknown':
+                    try:
+                        # Parse and format the date
+                        if 'T' in created:
+                            dt = datetime.fromisoformat(created.replace('Z', '+00:00'))
+                            created = dt.strftime('%m/%d %H:%M')
+                        else:
+                            created = created[:10]  # Just date part
+                    except:
+                        created = created[:16]
+                
+                conv_list += f"│ {i+1:2}. 💭 {topic:<45} │ {created:<10} │\n"
+                conv_list += f"│{'':<65}│\n"
+            
+            conv_list += f"""├─────────────────────────────────────────────────────────────────┤
+│  Type a number (1-{len(conversations[:10])}) to resume, or 'new' to start fresh   │
+└─────────────────────────────────────────────────────────────────┘
+```"""
+            
+            self.add_system_message(conv_list)
+            
+            # Store conversations for selection
+            self._available_conversations = conversations[:10]
+            self._selecting_conversation = True
+            
+        except Exception as e:
+            self.add_system_message(f"Error loading conversations: {e}")
+            await self.start_new_conversation()
+    
+    async def handle_conversation_selection(self, selection: str) -> None:
+        """Handle conversation selection by number"""
+        # Handle non-numeric inputs first
+        if selection.lower() in ['new', 'cancel']:
+            self._selecting_conversation = False
+            self._available_conversations = []
+            await self.start_new_conversation()
+            return
+            
+        # Try to parse as number
+        try:
+            conv_index = int(selection) - 1
+            if 0 <= conv_index < len(self._available_conversations):
+                selected_conv = self._available_conversations[conv_index]
+                self.conversation_id = selected_conv['uuid']
+                self.last_message_key = ""
+                self._selecting_conversation = False
+                self._available_conversations = []
+                
+                await self.clear_chat()
+                self.add_system_message(f"Resumed conversation: {selected_conv.get('topic', 'No topic')}")
+                
+                # Load conversation history
+                await self.load_conversation_history()
+                self.update_status("Ready")
+            else:
+                self.add_system_message(f"Invalid selection. Please choose 1-{len(self._available_conversations)} or type 'new' to cancel.")
+                
+        except ValueError:
+            self.add_system_message("Invalid input. Please enter a number or type 'new' to cancel.")
+    
+    async def load_conversation_history(self) -> None:
+        """Load and display conversation history"""
+        if not self.conversation_id:
+            return
+            
+        try:
+            # Load all messages for this conversation
+            messages, _ = self.sdk.search.by_key_prefix(f"#message#{self.conversation_id}#", user=True)
+            messages = sorted(messages, key=lambda x: x.get('key', ''))
+            
+            self.add_system_message(f"Loading {len(messages)} messages from conversation history...")
+            
+            for msg in messages:
+                role = msg.get('role')
+                content = msg.get('content', '')
+                
+                if role == 'user':
+                    self.add_user_message(content)
+                elif role == 'chariot':
+                    self.add_ai_message(content)
+                elif role == 'tool call':
+                    self.add_tool_message("🔧 Executing tool...")
+                elif role == 'tool response':
+                    self.add_tool_message("✅ Tool execution completed")
+                elif role == 'planner-output':
+                    self.add_system_message("🎯 Job completion processed")
+            
+            # Set last message key for future polling
+            if messages:
+                self.last_message_key = messages[-1].get('key', '')
+                
+            self.add_system_message("Conversation history loaded. You can continue the conversation.")
+            
+        except Exception as e:
+            self.add_system_message(f"Error loading conversation history: {e}")
+    
+    async def clear_chat(self) -> None:
+        """Clear the chat log"""
+        chat_log = self.query_one("#chat-log")
+        await chat_log.remove_children()
+    
+    async def show_job_status(self) -> None:
+        """Show active jobs for the current conversation"""
+        if not self.conversation_id:
+            self.add_system_message("No active conversation")
+            return
+            
+        try:
+            jobs, _ = self.sdk.search.by_term(f"conversation:{self.conversation_id}")
+            jobs = jobs if jobs else []
+            
+            if not jobs:
+                self.add_system_message("No jobs found for this conversation")
+                return
+            
+            # Create beautiful jobs table
+            job_summary = f"""
+# 🚀 Security Jobs Status
+
+**Conversation Jobs: {len(jobs)}**
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        ACTIVE SECURITY JOBS                     │
+├─────────────────────────────────────────────────────────────────┤
+"""
+            
+            for i, job in enumerate(jobs, 1):
+                status = job.get('status', '')
+                capability = job.get('source', 'unknown')
+                
+                # Extract target from job key
+                job_key = job.get('key', '')
+                if job_key.startswith('#job#'):
+                    parts = job_key.split('#')
+                    if len(parts) >= 3:
+                        target_part = parts[2]
+                        if target_part.startswith('#asset#'):
+                            asset_parts = target_part.split('#')
+                            target_display = asset_parts[3] if len(asset_parts) >= 4 else target_part
+                        else:
+                            target_display = target_part
+                    else:
+                        target_display = job_key
+                else:
+                    target_display = job.get('dns', 'unknown')
+                
+                # Map status to readable format with better emojis
+                status_info = {
+                    'JQ': ('🔵', 'QUEUED', 'Waiting to start'),
+                    'JR': ('🟡', 'RUNNING', 'Currently executing'), 
+                    'JP': ('🟢', 'COMPLETED', 'Successfully finished'),
+                    'JF': ('🔴', 'FAILED', 'Execution failed')
+                }
+                
+                emoji, status_name, description = status_info.get(status[:2], ('⚪', 'UNKNOWN', 'Status unknown'))
+                
+                # Format each job entry nicely
+                job_summary += f"│ {i:2}. {emoji} {status_name:<9} │ {capability:<15} │ {target_display:<25} │\n"
+                if len(jobs) <= 5:  # Show descriptions for small lists
+                    job_summary += f"│     {description:<60} │\n"
+                job_summary += f"│{'':<65}│\n"
+            
+            job_summary += "└─────────────────────────────────────────────────────────────────┘\n```"
+            
+            self.add_system_message(job_summary)
+            
+        except Exception as e:
+            self.add_system_message(f"Failed to get job status: {e}")
+
+
+def run_textual_conversation(sdk: Chariot) -> None:
+    """Run the Textual-based conversation interface"""
+    app = ConversationApp(sdk)
+    app.run()

{praetorian_cli-2.2.4.dist-info → praetorian_cli-2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praetorian-cli
-Version: 2.2.4
+Version: 2.2.5
 Summary: For interacting with the Chariot API
 Home-page: https://github.com/praetorian-inc/praetorian-cli
 Author: Praetorian

{praetorian_cli-2.2.4.dist-info → praetorian_cli-2.2.5.dist-info}/RECORD

@@ -1,15 +1,15 @@
 praetorian_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 praetorian_cli/main.py,sha256=AVrOCQgioLDKm-Y8-b3lLLdLtaO1WwOAzUfs0obe5Nw,1451
 praetorian_cli/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-praetorian_cli/handlers/add.py,sha256=1n0EZqlKsx2BX99jVs5-gwMKrnfJG4ajQajuWA6qMFI,13443
+praetorian_cli/handlers/add.py,sha256=gJoV4WqQbbWL-O84jXZK7HF0kiFNp9RkpDWPpN6CXAg,13854
 praetorian_cli/handlers/aegis.py,sha256=1259bNmoUOVhcs7GqI8TyTyCI_ZvKzEPvfUVvAHcTzU,3936
-praetorian_cli/handlers/agent.py,sha256=8lmb_R1aWe9bhk-4NPOfXXxaE8E_U97DFNEvJ2mcteg,2291
+praetorian_cli/handlers/agent.py,sha256=52_BcZF10VOuiwkySQpjeh07JdUKaMURo-RLVOINK1w,3165
 praetorian_cli/handlers/chariot.py,sha256=HClwYdsgFKlLY68RhV65W1Y4g-JgbBDdI4PdP4s8MgI,611
 praetorian_cli/handlers/cli_decorators.py,sha256=ZLPMZH9i-vNtTT0Y0qnYQsGw8B4lxIdEE1vBX9i75Wc,2884
 praetorian_cli/handlers/configure.py,sha256=8ABvisb_a4WekVVZ5kEhT1m4Mn2xV5RsO_xO_7f6TkM,1317
 praetorian_cli/handlers/delete.py,sha256=8K7yEnQQT88vbJG-ouX-aFq6FyjkWNGDMt97VYZGSZg,4433
 praetorian_cli/handlers/enrich.py,sha256=KRvOAuW7mQdYg_k_XOTwtPmnf8rxOAtoL00Bb0e-N-s,485
-praetorian_cli/handlers/get.py,sha256=l9fFo_pSLXIx5Ax6bmSXsVlT7jazzrB235usJJbx82Y,9356
+praetorian_cli/handlers/get.py,sha256=-_gfjPDN_H7tClHzKPN6jo-rtXsUMp7NaQ_YrdEajX4,9564
 praetorian_cli/handlers/imports.py,sha256=u1TK4w3eCMD5ASPFare2NgTX1_m0_F1ELCmvV7OF-PI,1653
 praetorian_cli/handlers/link.py,sha256=7JjHoawFZbcfropHVp8IX3Ekci6theAlcYSTPXnrFHQ,1776
 praetorian_cli/handlers/list.py,sha256=bTPztFlyHHyCO5y5pDOw68CDxGN_Ps8DrhbStgSFgrc,13217
@@ -19,7 +19,7 @@ praetorian_cli/handlers/ssh_utils.py,sha256=53Kke-iFH4sJoCcweiT8q4WVRlaA7SvR5CCq
 praetorian_cli/handlers/test.py,sha256=uhARoRolaJf6DMRNX-1aj8SDYe1wAvhYDOBYWH39sqo,932
 praetorian_cli/handlers/unlink.py,sha256=nUTGXZ7JBXwuHy2nzvL79sSO95Vyc0PftM6rm-9YWt8,1725
 praetorian_cli/handlers/update.py,sha256=rgdOsFTaEivTdTUjUxPNEo13XR7uoIpBFRUqUdFVjaI,2846
-praetorian_cli/handlers/utils.py,sha256=2WA_50l6bWo-00cpxsHtqZYF10pSVxwly94qjl_tutY,858
+praetorian_cli/handlers/utils.py,sha256=PaHyDTF2uj6mMMIr1pP1Bfh22H3dMx_UWnJgXK7_yuY,2639
 praetorian_cli/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 praetorian_cli/scripts/utils.py,sha256=lGCf4trEpsfECa9U42pDJ-f48EimlS-hG6AjnKjNt4I,501
 praetorian_cli/scripts/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -35,10 +35,10 @@ praetorian_cli/sdk/entities/agents.py,sha256=tJXTBkU7EpLVfhKo7g5pQfcXJeylLEfeLIp
 praetorian_cli/sdk/entities/assets.py,sha256=z8ErleQQ-BdnYkwPWOp2EQ8eJI4YB8qi45XQMokDFK8,5930
 praetorian_cli/sdk/entities/attributes.py,sha256=AyWsYyjUFNbHTCN7j-OYA7YD1Y0z_LmnlcME5y74je8,3573
 praetorian_cli/sdk/entities/capabilities.py,sha256=WeNlPrhVgLQPbpqYvS4nHmIX697ITpoZkJeLYxG5bmY,2808
-praetorian_cli/sdk/entities/configurations.py,sha256=rIChKvkaHUv9XRtQJ6OYH3gDDMcN8OPVsM_ylPnPEoI,4255
+praetorian_cli/sdk/entities/configurations.py,sha256=y32_QYSS6MgGDyz0tEuJgG6jWCI4Vyzwyf0m4SVtVNw,4249
 praetorian_cli/sdk/entities/credentials.py,sha256=BfNBe_0P6-qtwJFicyrAeTWmWttDtaEnTo8nr3pqYoo,5108
-praetorian_cli/sdk/entities/definitions.py,sha256=4cTHBoXwUgKVVvh3nOqphtwMlQVPaFM2BFayP1E9Ucg,2765
-praetorian_cli/sdk/entities/files.py,sha256=IMPY9KswD5qdhkoC9hBGAoPDEc1XOduIuTYiUg0hPss,5506
+praetorian_cli/sdk/entities/definitions.py,sha256=rpuNLM3DZxMr5YINYDD6ePWG1TEI1biZ4IqnjpDAEh0,3125
+praetorian_cli/sdk/entities/files.py,sha256=Gw9Yt_Cm2xR-Vu8vjaekMHbGldhe930WJjjeaJrBLxg,5822
 praetorian_cli/sdk/entities/integrations.py,sha256=NVaW_dWbnMkMIs-EYr2W7QAeamPVwLhmM2ppdMJmsK0,3176
 praetorian_cli/sdk/entities/jobs.py,sha256=JBkNgFzQEtV0XJSuKtAzCHOYa9rcVxgTkp-tAuS6CP0,8181
 praetorian_cli/sdk/entities/keys.py,sha256=PgoGa3xyLMzWrIIQ8zgi7bfZiUFFumPtMDo64GjhdjE,6089
@@ -46,7 +46,7 @@ praetorian_cli/sdk/entities/preseeds.py,sha256=SeSY4K6diJMQzsjCBxYK3N9Lz0fUz3B_L
 praetorian_cli/sdk/entities/risks.py,sha256=ZJ9_S8Zf3RwB7wGRjGEpf8j1jTB_leJiyHlFWeXsefc,5953
 praetorian_cli/sdk/entities/scanners.py,sha256=QCr5QlBy4jfBh8HRvZt9CoZTgNqLNnKNrI4sdfJf0jE,423
 praetorian_cli/sdk/entities/schema.py,sha256=CPVws1CdRHyOAI7oT9A20WGOCZozTFqZnfo5ox3v0HQ,807
-praetorian_cli/sdk/entities/search.py,sha256=hFoANI_arlEmFPQwDiEF7lU-kPgXk0z3VyjubOULhRE,16843
+praetorian_cli/sdk/entities/search.py,sha256=9vTy9HZY2BTlqf5Zwpdl8HCRIfSEvWDRij2_-rAp2Ng,16938
 praetorian_cli/sdk/entities/seeds.py,sha256=eYDFtfgzIX_o9c5wuPiz9I2xDfTz7k9PZPzL7A7x1CM,5404
 praetorian_cli/sdk/entities/settings.py,sha256=F-pRCA6UvbdtnjHOLpEG2lN9ws8dcnBNcep-DFlXeTY,2750
 praetorian_cli/sdk/entities/statistics.py,sha256=gtX-NN7r_RsNjDjlQ-zspmzG_0bzBqBFarCuM4NO-EA,7085
@@ -54,7 +54,7 @@ praetorian_cli/sdk/entities/webhook.py,sha256=7Bqt20GlJFbZTlmQwYTuUadsUQvydym6S4
 praetorian_cli/sdk/entities/webpage.py,sha256=FBS3HzuUJnQR9Blm_cBCd9efYAdc2wA2tUFY-cpLj4k,6787
 praetorian_cli/sdk/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 praetorian_cli/sdk/model/aegis.py,sha256=KNeynkCJtaR5bIhv3-VNirjxq4i-6JhCZGTb5rmxkQ4,5344
-praetorian_cli/sdk/model/globals.py,sha256=DxzOyYrVnu9FyvN_L69-1tAmLrFYSQ-nu1xiF8Mmg1I,2961
+praetorian_cli/sdk/model/globals.py,sha256=8nQjs4KD3BR0CWAyE4YAgSCwse4Mtj4wADIGx1avf8M,2990
 praetorian_cli/sdk/model/query.py,sha256=lqYC_RJRBCSQRPmElmBH6VXcXS8Z8AriLpG7DYUkFhI,6523
 praetorian_cli/sdk/model/utils.py,sha256=G8cU7K2uG0-J0GanjcCrzDuUtKzDOucFWF6hGtfOsTM,781
 praetorian_cli/sdk/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -65,6 +65,7 @@ praetorian_cli/sdk/test/test_asset.py,sha256=jcnSJxgnLhRgJ_cjkrlLQTlAYg3wruMsEIn
 praetorian_cli/sdk/test/test_attribute.py,sha256=AwD_w488rKhc1mxTBwSJcItmhcIYHJHX5DjgQYE3uPo,1169
 praetorian_cli/sdk/test/test_capabilities.py,sha256=HoAu_WFjqVkwciPgrLp5z0-UbkuqKdqD46jb_8o1PbM,407
 praetorian_cli/sdk/test/test_configuration.py,sha256=ysyWpt7iq_tNkdvLU8gULCuwbXVqt2HMXgZpWLnWccg,2174
+praetorian_cli/sdk/test/test_conversation.py,sha256=QsLQAdYMcg3xIET8RBgD81D4CqqS0D9cp7-sEuqApR0,6933
 praetorian_cli/sdk/test/test_definition.py,sha256=8ShZFXJYHJUPH5rfmF3LYk9NE8W4lJBNHE2DhyJgXaY,1016
 praetorian_cli/sdk/test/test_extend.py,sha256=bHTCwtW0jN1GvFocB_uMJcEj4_IXvCkr35yMWKESbTU,1778
 praetorian_cli/sdk/test/test_file.py,sha256=rRikM2ceMy5TEX7YOFMPB2dnCRqROE9w8qoqVeCs9HM,2133
@@ -78,7 +79,7 @@ praetorian_cli/sdk/test/test_seed.py,sha256=WfnEPZwMXHFtt4jyVT-1JitIW1zTrl7rwlX8
 praetorian_cli/sdk/test/test_setting.py,sha256=hdPQj71rjSYxa-PODG2D-kJd8C9gkAg1jQXnqYU4P6A,1326
 praetorian_cli/sdk/test/test_webhook.py,sha256=FQJY76QQ6Yg2iLCGpxgKiXGI8TtmB4zTpMIM2SpYKCc,2228
 praetorian_cli/sdk/test/test_webpage.py,sha256=jgKrsobD3ONibDIbbOT-yy7V_NmC5-LwEZmEYdYu0LI,1779
-praetorian_cli/sdk/test/test_z_cli.py,sha256=2_cUOExQJOuTVJUdzBmZsQz9tgf6D8M_o2XEIW5-HQY,19234
+praetorian_cli/sdk/test/test_z_cli.py,sha256=z2gcA9w7Qw6assGMLOrFG3jKmbGWSueSQL0g5zYMvQE,20670
 praetorian_cli/sdk/test/ui_mocks.py,sha256=kiqAPxaM-_T0NQ-HgOZupNiUoJa5mE2CsyK2cXWiPws,4146
 praetorian_cli/sdk/test/utils.py,sha256=svxMpzlaW4FRCij05cPgJFrTUEELVdt8G7SPKEdsgPo,3526
 praetorian_cli/ui/__init__.py,sha256=wEgkrgIaoOguH1VVp2FndaGIxWmZ5CfAynXtNtZ6iTo,81
@@ -93,9 +94,11 @@ praetorian_cli/ui/aegis/commands/job.py,sha256=BUcp47K-4PBIYq9nyUQTKhOakZwXM4fOf
 praetorian_cli/ui/aegis/commands/list.py,sha256=puIiy0skYE59Q2hVSMsla1tKiYYAFTOaz8oPM17tCyI,352
 praetorian_cli/ui/aegis/commands/set.py,sha256=ODa9u_6yW2dbKVQBuV9YeiS_ty_R_Xk_vPz7YrW3OWs,1101
 praetorian_cli/ui/aegis/commands/ssh.py,sha256=KGsNlN0i-Cwp6gWyr-cjML9_L13oE7xFenysF2pC8Rc,3045
-praetorian_cli-2.2.4.dist-info/licenses/LICENSE,sha256=Zv97QripiVALv-WokW_Elsiz9vtOfbtNt1aLZhhk67I,1067
-praetorian_cli-2.2.4.dist-info/METADATA,sha256=Zfbe0aPsveflR-8qlRyKbgL6kC0_vx9RjQY1qZQmrtE,7751
-praetorian_cli-2.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praetorian_cli-2.2.4.dist-info/entry_points.txt,sha256=uJbDvZdkYaLiCh2DMvXPUGKFm2p5ZfzJCizUK3-PUEE,56
-praetorian_cli-2.2.4.dist-info/top_level.txt,sha256=QbUdRPGEj_TyHO-E7AD5BxFfR8ore37i273jP4Gn43c,15
-praetorian_cli-2.2.4.dist-info/RECORD,,
+praetorian_cli/ui/conversation/__init__.py,sha256=sNhNN_ZG1Va_7OLTaoXlIFL6ageKHWdufFVYw6F_aV8,90
+praetorian_cli/ui/conversation/textual_chat.py,sha256=bvTaBm_ZCPI4Z1HDn3e-GfH2z4JVLcuFh3SX0BHtcGE,24403
+praetorian_cli-2.2.5.dist-info/licenses/LICENSE,sha256=Zv97QripiVALv-WokW_Elsiz9vtOfbtNt1aLZhhk67I,1067
+praetorian_cli-2.2.5.dist-info/METADATA,sha256=QmLUy78-ijFSJl2oCskS-ow3qyrBwTSxu1RdlmpE0Mo,7751
+praetorian_cli-2.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praetorian_cli-2.2.5.dist-info/entry_points.txt,sha256=uJbDvZdkYaLiCh2DMvXPUGKFm2p5ZfzJCizUK3-PUEE,56
+praetorian_cli-2.2.5.dist-info/top_level.txt,sha256=QbUdRPGEj_TyHO-E7AD5BxFfR8ore37i273jP4Gn43c,15
+praetorian_cli-2.2.5.dist-info/RECORD,,