praetorian-cli 2.2.2__tar.gz → 2.2.3__tar.gz

{praetorian_cli-2.2.2/praetorian_cli.egg-info → praetorian_cli-2.2.3}/PKG-INFO

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

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/handlers/add.py

@@ -196,21 +196,39 @@ def attribute(sdk, key, name, value):
 
 @add.command()
 @cli_handler
-@click.option('-d', '--dns', required=True, help='The DNS of the asset')
+@click.option('-t', '--type', 'seed_type', default='asset', help='Asset type (e.g., asset, addomain)')
 @click.option('-s', '--status', type=click.Choice([s.value for s in Seed]),
               default=Seed.PENDING.value, help='The status of the seed', show_default=True)
-def seed(sdk, dns, status):
+@click.option('-f', '--field', 'field_list', multiple=True, 
+              help='Field in format name:value (can be specified multiple times)')
+def seed(sdk, seed_type, status, field_list):
     """ Add a seed
 
-    Add a seed to the Chariot database. This command requires DNS of the seed to be
-    specified. When status is not specified, the seed is added as PENDING.
+    Add a seed to the Chariot database. Seeds are now assets with special labeling.
+    You can specify the asset type and provide dynamic fields using --fields.
 
     \b
     Example usages:
-        - praetorian chariot add seed --dns example.com
-        - praetorian chariot add seed --dns example.com --status A
+        - praetorian chariot add seed --type asset --field dns:example.com
+        - praetorian chariot add seed --type asset --field dns:example.com --status A
+        - praetorian chariot add seed --type asset --field dns:example.com --field name:1.2.3.4
+        - praetorian chariot add seed --type addomain --field domain:corp.local --field objectid:S-1-5-21-2701466056-1043032755-2418290285
     """
-    sdk.seeds.add(dns, status)
+    # Collect dynamic fields from the --fields option
+    dynamic_fields = {}
+    
+    # Parse field_list entries (name:value format)
+    for field in field_list:
+        if ':' in field:
+            # Split only once to allow colons in the value
+            name, value = field.split(':', 1)
+            dynamic_fields[name] = value
+        else:
+            error(f"Field '{field}' is not in the format name:value")
+            return
+    
+    # Call the updated add method with type and dynamic fields
+    sdk.seeds.add(status=status, seed_type=seed_type, **dynamic_fields)
 
 
 @add.command()

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/handlers/delete.py

@@ -88,11 +88,12 @@ def seed(chariot, key):
 
     \b
     Arguments:
-        - KEY: the key of an existing seed
+        - KEY: the key of an existing seed (now uses asset key format)
 
     \b
     Example usage:
-        - praetorian chariot delete seed "#seed#domain#example.com"
+        - praetorian chariot delete seed "#asset#example.com#example.com"
+        - praetorian chariot delete seed "#addomain#corp.local#corp.local"
     """
     chariot.seeds.delete(key)
 

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/handlers/get.py

@@ -186,11 +186,12 @@ def seed(chariot, key):
 
     \b
     Argument:
-        - KEY: the key of an existing pre-seed
+        - KEY: the key of an existing seed (now uses asset key format)
 
     \b
     Example usages:
-        - praetorian chariot get preseed "#preseed#domain#example.com"
+        - praetorian chariot get seed "#asset#example.com#example.com"
+        - praetorian chariot get seed "#addomain#corp.local#corp.local"
     """
     print_json(chariot.seeds.get(key))
 
@@ -295,3 +296,31 @@ def scanner(chariot, key):
         - praetorian chariot get scanner "#scanner#127.0.0.1"
     """
     print_json(chariot.scanners.get(key))
+
+
+@get.command()
+@cli_handler
+@click.option('-t', '--type', help='Optional specific entity type (e.g., asset, risk, attribute)')
+@click.option('-d', '--details', is_flag=True, help='Further retrieve the details of the schema')
+def schema(chariot, type, details):
+    """ Get Chariot entity schema
+
+    \b
+    Returns the JSON schema for Chariot entities. Optionally filter for a
+    specific entity type.
+
+    \b
+    Example usages:
+        - praetorian chariot get schema
+        - praetorian chariot get schema --type asset
+        - praetorian chariot get schema --type asset --details
+    """
+    data = chariot.schema.get(type)
+    if type:
+        data = {type: data[type]}
+
+    if details:
+        print_json(data)
+    else:
+        for hit in data:
+            click.echo(hit)

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/handlers/list.py

@@ -26,7 +26,7 @@ def assets(chariot, filter, model_type, details, offset, page):
         - praetorian chariot list assets --page all
         - praetorian chariot list assets --type repository
     """
-    render_list_results(chariot.assets.list(filter, model_type, offset, pagination_size(page)), details)
+    render_list_results(chariot.assets.list(filter, model_type, pagination_size(page)), details)
 
 
 @list.command()
@@ -178,24 +178,23 @@ def attributes(chariot, filter, key, details, offset, page):
 
 @list.command()
 @list_params('DNS')
-@click.option('-t', '--type', type=click.Choice(['ip', 'domain']), help=f'Filter by type of the seeds')
+@click.option('-t', '--type', help='Filter by seed type (e.g., asset, addomain)')
 def seeds(chariot, type, filter, details, offset, page):
     """ List seeds
 
-   	Retrieve and display a list of seeds.
+   	Retrieve and display a list of seeds. Seeds are now assets with the 'Seed' label.
 
     \b
     Example usages:
         - praetorian chariot list seeds
-        - praetorian chariot list seeds --type ip
-        - praetorian chariot list seeds --type domain --filter example.com
+        - praetorian chariot list seeds --type asset
+        - praetorian chariot list seeds --type addomain
+        - praetorian chariot list seeds --type asset --filter example.com
         - praetorian chariot list seeds --details
         - praetorian chariot list seeds --page all
     """
-    if filter and not type:
-        error('When the DNS filter is specified, you also need to specify the type of the filter: ip or domain.')
-
-    render_list_results(chariot.seeds.list(type, filter, offset, pagination_size(page)), details)
+    # Note: filter restriction removed since we're using different key format now
+    render_list_results(chariot.seeds.list(type, filter, pagination_size(page)), details)
 
 
 @list.command()

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/handlers/update.py

@@ -65,12 +65,12 @@ def seed(chariot, key, status):
 
     \b
     Example usages:
-        - praetorian chariot update seed "#seed#domain#example.com" -s A
-        - praetorian chariot update seed "#seed#ip#1.1.1.0/24" -s F
+        - praetorian chariot update seed "#asset#example.com#example.com" -s A
+        - praetorian chariot update seed "#asset#1.1.1.0/24#1.1.1.0/24" -s F
     """
+    
     chariot.seeds.update(key, status)
 
-
 @update.command()
 @cli_handler
 @click.argument('key', required=True)

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/chariot.py

@@ -16,6 +16,7 @@ from praetorian_cli.sdk.entities.keys import Keys
 from praetorian_cli.sdk.entities.preseeds import Preseeds
 from praetorian_cli.sdk.entities.risks import Risks
 from praetorian_cli.sdk.entities.scanners import Scanners
+from praetorian_cli.sdk.entities.schema import Schema
 from praetorian_cli.sdk.entities.search import Search
 from praetorian_cli.sdk.entities.seeds import Seeds
 from praetorian_cli.sdk.entities.settings import Settings
@@ -51,6 +52,7 @@ class Chariot:
         self.keys = Keys(self)
         self.capabilities = Capabilities(self)
         self.credentials = Credentials(self)
+        self.schema = Schema(self)
         self.proxy = proxy
 
         if self.proxy == '' and os.environ.get('CHARIOT_PROXY'):
@@ -70,26 +72,16 @@ class Chariot:
             kwargs['proxies'] = {'http': self.proxy, 'https': self.proxy}
             kwargs['verify'] = False
         
-        self._add_beta_filter(method, kwargs)
+        self.add_beta_url_param(kwargs)
 
         return requests.request(method, url, headers=self.keychain.headers(), **kwargs)
 
-    def _add_beta_filter(self, method: str, kwargs: dict):
-        if method == 'GET' or method == 'DELETE':
-            self._add_beta_url_param(kwargs)
-        else:
-            self._add_beta_json_param(kwargs)
-
-    def _add_beta_url_param(self, kwargs: dict):
+    def add_beta_url_param(self, kwargs: dict):
         if 'params' in kwargs:
             kwargs['params']['beta'] = 'true'
         else:
             kwargs['params'] = {'beta': 'true'}
 
-    def _add_beta_json_param(self, kwargs: dict):
-        if 'json' in kwargs:
-            kwargs['json']['beta'] = True
-
     def my(self, params: dict, pages=1) -> dict:
         final_resp = dict()
 

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/entities/assets.py

@@ -1,5 +1,6 @@
+from praetorian_cli.handlers.utils import error
 from praetorian_cli.sdk.model.globals import Asset, Kind
-from praetorian_cli.sdk.model.query import Relationship, Node, Query, asset_of_key, RISK_NODE, ATTRIBUTE_NODE
+from praetorian_cli.sdk.model.query import Relationship, Node, Query, Filter, KIND_TO_LABEL, asset_of_key, RISK_NODE, ATTRIBUTE_NODE
 
 
 class Assets:
@@ -76,27 +77,44 @@ class Assets:
         """
         return self.api.delete_by_key('asset', key)
 
-    def list(self, prefix_filter='', asset_type='', offset=None, pages=100000) -> tuple:
+    def list(self, key_prefix='', asset_type='', pages=100000) -> tuple:
         """
         List assets.
 
-        :param prefix_filter: Supply this to perform prefix-filtering of the asset keys after the "#asset#" portion of the asset key. Asset keys read '#asset#{dns}#{name}'
-        :type prefix_filter: str
+        :param key_prefix: Supply this to perform prefix-filtering of the asset key. E.g., '#asset#example.com' or '#addomain#sevenkingdoms'
+        :type key_prefix: str
         :param asset_type: The type of asset to filter by
         :type asset_type: str
-        :param offset: The offset of the page you want to retrieve results. If this is not supplied, this function retrieves from the first page
-        :type offset: str or None
         :param pages: The number of pages of results to retrieve. <mcp>Start with one page of results unless specifically requested.</mcp>
         :type pages: int
         :return: A tuple containing (list of assets, next page offset)
         :rtype: tuple
         """
-        dns_prefix = ''
-        if prefix_filter:
-            dns_prefix = f'group:{prefix_filter}'
-        if asset_type == '':
-            asset_type = Kind.ASSET.value
-        return self.api.search.by_term(dns_prefix, asset_type, offset, pages)
+
+        if asset_type in KIND_TO_LABEL:
+            asset_type = KIND_TO_LABEL[asset_type]
+        elif not asset_type:
+            asset_type = Node.Label.ASSET
+        else:
+            raise ValueError(f'Invalid asset type: {asset_type}')
+
+        node = Node(
+            labels=[asset_type],
+            filters=[]
+        )
+
+        key_filter = Filter(
+            field=Filter.Field.KEY,
+            operator=Filter.Operator.STARTS_WITH,
+            value=key_prefix
+        )
+
+        if key_prefix:
+            node.filters.append(key_filter)
+
+        query = Query(node=node)
+
+        return self.api.search.by_query(query, pages)
 
     def attributes(self, key):
         """

praetorian_cli-2.2.3/praetorian_cli/sdk/entities/schema.py

@@ -0,0 +1,27 @@
+class Schema:
+    """Access Chariot entity schemas via the SDK.
+
+    Methods in this class are accessed from `sdk.schema`, where `sdk` is an
+    instance of `Chariot`.
+    """
+
+    def __init__(self, api):
+        self.api = api
+
+    def get(self, entity_type: str | None = None) -> dict:
+        """Get schema information for entity types.
+
+        Args:
+            entity_type: Optional specific entity type. If provided and it exists,
+                only that schema is returned. If not provided, all schemas are returned.
+
+        Returns:
+            dict: Schema information.
+        """
+        result = self.api.get('schema', )
+        if entity_type:
+            if entity_type not in result:
+                return {}
+            return {entity_type: result[entity_type]}
+        return result
+

praetorian_cli-2.2.3/praetorian_cli/sdk/entities/seeds.py

@@ -0,0 +1,166 @@
+from praetorian_cli.handlers.utils import error
+from praetorian_cli.sdk.model.globals import Seed, Kind
+from praetorian_cli.sdk.model.query import Query, Node, Filter, KIND_TO_LABEL
+
+
+class Seeds:
+    """ The methods in this class are to be assessed from sdk.seeds, where sdk is an instance
+    of Chariot. """
+
+    def __init__(self, api):
+        self.api = api
+
+    def add(self, status=Seed.PENDING.value, seed_type=Kind.ASSET.value, **kwargs):
+        """
+        Add a seed of specified type with dynamic fields.
+        
+        :param status: Status for backward compatibility  
+        :type status: str or None
+        :param type: Asset type (e.g., 'asset', 'addomain', etc.)
+        :type type: str
+        :param kwargs: Dynamic fields for the asset type
+        :return: The seed that was added
+        :rtype: dict
+        """
+        # Handle status if provided
+        kwargs['status'] = status
+            
+        # Build payload with type wrapper
+        payload = {
+            'type': seed_type,
+            'model': kwargs
+        }
+
+        return self.api.upsert('seed', payload)
+
+    def get(self, key):
+        """
+        Get details of a seed by key.
+
+        :param key: Entity key (e.g., '#asset#example.com#example.com')
+        :type key: str
+        :return: The seed matching the specified key, or None if not found
+        :rtype: dict or None
+        """
+        
+        # Create a Filter for the key field
+        key_filter = Filter(
+            field=Filter.Field.KEY,
+            operator=Filter.Operator.EQUAL,
+            value=key
+        )
+        
+        # Create a Node with Seed label and key filter
+        node = Node(
+            labels=[Node.Label.SEED],
+            filters=[key_filter]
+        )
+        
+        # Create the Query object
+        query = Query(node=node)
+        
+        # Call by_query with the constructed Query object
+        results_tuple = self.api.search.by_query(query)
+        if not results_tuple:
+            return None
+        
+        results, _ = results_tuple
+        if len(results) == 0:
+            return None
+        return results[0]
+
+    def update(self, key, status=None):
+        """
+        Update seed fields dynamically.
+        
+        :param key: Seed/Asset key (e.g., '#seed#domain#example.com' or '#asset#domain#example.com')
+        :type key: str
+        :param status: Status for backward compatibility (can be positional)
+        :type status: str or None
+        :param kwargs: Fields to update
+        :return: The updated seed, or None if the seed was not found
+        :rtype: dict or None
+        """
+            
+        seed = self.get(key)  # This already handles old key format conversion
+        if seed:
+            update_payload = {
+                'key': key,
+                'status': status
+            }
+            
+            return self.api.upsert('seed', update_payload)
+        else:
+            error(f'Seed {key} not found.')
+
+    def delete(self, key):
+        """
+        Delete seed (supports both old and new key formats).
+        
+        :param key: Seed/Asset key (e.g., '#asset#domain#example.com')
+        :type key: str
+        :return: The seed that was marked as deleted, or None if the seed was not found
+        :rtype: dict or None
+        """
+        seed = self.get(key)  # This already handles old key format conversion
+        
+        if seed:
+            delete_payload = {
+                'key': key,
+                'status': Seed.DELETED.value
+            }
+            
+            return self.api.upsert('seed', delete_payload)
+        else:
+            error(f'Seed {key} not found.')
+
+    def list(self, seed_type=Kind.SEED.value, key_prefix='', pages=100000) -> tuple:
+        """
+        List seeds by querying assets with 'Seed' label.
+        
+        :param seed_type: Optional asset seed_type filter (e.g., 'asset', 'addomain')
+        :seed_type seed_type: str or None
+        :param key_prefix: Filter by key prefix
+        :seed_type key_prefix: str
+        :param pages: The number of pages of results to retrieve. <mcp>Start with one page of results unless specifically requested.</mcp>
+        :seed_type pages: int
+        :return: A tuple containing (list of seeds, next page offset)
+        :rseed_type: tuple
+        """
+
+        if seed_type in KIND_TO_LABEL:
+            seed_type = KIND_TO_LABEL[seed_type]
+        elif not seed_type:
+            seed_type = Node.Label.SEED
+        else:
+            raise ValueError(f'Invalid seed type: {seed_type}')
+
+        node = Node(
+            labels=[seed_type],
+            filters=[]
+        )
+
+        key_filter = Filter(
+                field=Filter.Field.KEY,
+                operator=Filter.Operator.STARTS_WITH,
+                value=key_prefix
+            )
+
+        if key_prefix:
+            node.filters.append(key_filter)
+        
+        query = Query(node=node)
+        
+        return self.api.search.by_query(query, pages)
+
+    def attributes(self, key):
+        """
+        Get attributes associated with a seed.
+
+        :param key: Entity key in format #seed#{type}#{dns} where type is 'domain', 'ip', or 'cidr' and dns is the seed value
+        :type key: str
+        :return: List of attributes associated with the seed
+        :rtype: list
+        """
+        attributes, _ = self.api.search.by_source(key, Kind.ATTRIBUTE.value)
+        return attributes

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/mcp_server.py

@@ -8,7 +8,6 @@ from mcp.server.lowlevel import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import Tool, TextContent
 
-
 class MCPServer:
     def __init__(self, chariot_instance, allowable_tools: Optional[List[str]] = None):
         self.chariot = chariot_instance
@@ -157,7 +156,7 @@ class MCPServer:
             tools = []
             for tool_name, tool_info in self.discovered_tools.items():
                 parameters = self._extract_parameters_from_doc(tool_info['doc'], tool_info['signature'])
-                
+
                 properties = {}
                 required = []
                 
@@ -170,7 +169,7 @@ class MCPServer:
                         "description": param_info["description"]
                     }
                     
-                    if param_info["required"]:
+                    if param_info.get("required", False):
                         required.append(param_name)
                 
                 tool_schema = {

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/model/query.py

@@ -91,7 +91,7 @@ class Node:
         ASSET = 'Asset'
         REPOSITORY = 'Repository'
         INTEGRATION = 'Integration'
-        ADDOMAIN = 'Addomain'
+        ADDOMAIN = 'ADDomain'
         ATTRIBUTE = 'Attribute'
         RISK = 'Risk'
         PRESEED = 'Preseed'

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/model/utils.py

@@ -15,14 +15,11 @@ def integration_key(dns, name):
 def risk_key(dns, name):
     return f'#risk#{dns}#{name}'
 
-
 def attribute_key(name, value, source_key):
     return f'#attribute#{name}#{value}{source_key}'
 
-
-def seed_key(type, dns):
-    return f'#seed#{type}#{dns}'
-
+def seed_asset_key(dns):
+    return f'#asset#{dns}#{dns}'
 
 def preseed_key(type, title, value):
     return f'#preseed#{type}#{title}#{value}'
@@ -32,6 +29,3 @@ def setting_key(name):
 
 def configuration_key(name):
     return f'#configuration#{name}'
-
-def seed_status(type, status_code):
-    return f'{type}#{status_code}'

{praetorian_cli-2.2.2 → praetorian_cli-2.2.3}/praetorian_cli/sdk/test/test_asset.py

@@ -42,7 +42,7 @@ class TestAsset:
         assert any([a['group'] == self.asset_dns for a in deleted_assets])
     
     def test_add_ad_domain(self):
-        asset = self.sdk.assets.add(self.ad_domain_name, self.ad_domain_name, status=Asset.ACTIVE.value, surface='test-surface', type=Kind.ADDOMAIN.value)
+        asset = self.sdk.assets.add(self.ad_domain_name, self.ad_object_id, status=Asset.ACTIVE.value, surface='test-surface', type=Kind.ADDOMAIN.value)
         assert asset['key'] == self.ad_domain_key
         assert len(asset['attackSurface']) == 1
         assert 'test-surface' in asset['attackSurface']
@@ -51,7 +51,7 @@ class TestAsset:
     def test_get_ad_domain(self):
         asset = self.sdk.assets.get(self.ad_domain_key)
         assert asset['key'] == self.ad_domain_key
-        assert asset['name'] == self.ad_domain_name
+        assert asset['domain'] == self.ad_domain_name
         assert asset['status'] == Asset.ACTIVE.value
     
     def test_list_ad_domain(self):

praetorian_cli-2.2.3/praetorian_cli/sdk/test/test_seed.py

@@ -0,0 +1,40 @@
+import pytest
+
+from praetorian_cli.sdk.model.globals import Seed, Kind
+from praetorian_cli.sdk.test.utils import make_test_values, clean_test_entities, setup_chariot
+
+
+@pytest.mark.coherence
+class TestSeed:
+
+    def setup_class(self):
+        self.sdk = setup_chariot()
+        make_test_values(self)
+
+    def test_add_asset_seed(self):
+        seed = self.sdk.seeds.add(dns=self.seed_asset_dns)
+        assert seed['key'] == self.seed_asset_key
+
+    def test_get_seed(self):
+        a = self.get_seed()
+        assert a['dns'] == self.seed_asset_dns
+        assert a['status'] == Seed.PENDING.value
+
+    def test_list_seed(self):
+        results, _ = self.sdk.seeds.list(Kind.ASSET.value, f"#asset#{self.seed_asset_dns}")
+        assert len(results) == 1
+        assert results[0]['dns'] == self.seed_asset_dns
+
+    def test_update_seed(self):
+        self.sdk.seeds.update(self.seed_asset_key, Seed.ACTIVE.value)
+        assert self.get_seed()['status'] == Seed.ACTIVE.value
+
+    def test_delete_seed(self):
+        self.sdk.seeds.delete(self.seed_asset_key)
+        assert self.sdk.seeds.get(self.seed_asset_key)['status'] == Seed.DELETED.value
+
+    def get_seed(self):
+        return self.sdk.seeds.get(self.seed_asset_key)
+
+    def teardown_class(self):
+        clean_test_entities(self.sdk, self)