stoobly-agent 0.29.2__py3-none-any.whl → 0.30.1__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '0.29.2'
+VERSION = '0.30.1'

stoobly_agent/app/cli/config_cli.py

@@ -8,7 +8,7 @@ from stoobly_agent.app.settings import Settings
 from stoobly_agent.app.settings.constants import firewall_action, request_component
 from stoobly_agent.app.settings.firewall_rule import FirewallRule
 from stoobly_agent.app.settings.match_rule import MatchRule
-from stoobly_agent.app.settings.rewrite_rule import ParameterRule, RewriteRule
+from stoobly_agent.app.settings.rewrite_rule import ParameterRule, RewriteRule, UrlRule
 from stoobly_agent.config.constants import mode
 from stoobly_agent.config.data_dir import DataDir
 from stoobly_agent.lib.api.keys import ProjectKey, ScenarioKey
@@ -146,6 +146,7 @@ def rewrite(ctx):
 @rewrite.command(
     help="Set rewrite rule."
 )
+@click.option('--host', help='Request URL host.')
 @click.option(
     '--method', 
     multiple=True, 
@@ -159,17 +160,30 @@ def rewrite(ctx):
     required=True,
     type=click.Choice([mode.MOCK, mode.RECORD, mode.REPLAY] + ([mode.TEST] if is_remote else []))
 )
-@click.option('--name', required=True, help='Name of the request component.')
+@click.option('--name', help='Name of the request component.')
 @click.option('--pattern', required=True, help='URLs pattern.')
+@click.option('--port', help='Request URL port.')
 @click.option('--project-key', help='Project to add rewrite rule to.')
 @click.option(
     '--type', 
-    required=True,
     type=click.Choice([request_component.BODY_PARAM, request_component.HEADER, request_component.QUERY_PARAM]), 
     help='Request component type.'
 )
-@click.option('--value', required=True, help='Rewrite value.')
+@click.option('--value', help='Rewrite value.')
 def set(**kwargs):
+    if kwargs['name'] or kwargs['value'] or kwargs['type']:
+        if kwargs['name'] == None:
+            print("Error: missing option '--name'", file=sys.stderr)
+            sys.exit(1)
+
+        if kwargs['value'] == None:
+            print("Error: missing option '--value'", file=sys.stderr)
+            sys.exit(1)
+        
+        if kwargs['type'] == None:
+            print("Error: missing option '--type'", file=sys.stderr)
+            sys.exit(1)
+
     settings = Settings.instance()
     project_key_str = resolve_project_key_and_validate(kwargs, settings)
     project_key = ProjectKey(project_key_str)
@@ -183,27 +197,50 @@ def set(**kwargs):
     filtered_rewrite_rules: List[RewriteRule] = list(filter(rewrite_rule_filter, rewrite_rules))
 
     if len(filtered_rewrite_rules) == 0:
+        parameter_rules = list(filter(lambda r: r != None, [__select_parameter_rule(kwargs)]))
+        url_rules = list(filter(lambda r: r != None , [__select_url_rule(kwargs)]))
         rewrite_rule = RewriteRule({
             'methods': methods,
             'pattern': kwargs['pattern'],
-            'parameter_rules': [__select_parameter_rule(kwargs)]
+            'parameter_rules': parameter_rules,
+            'url_rules': url_rules,
         })
         rewrite_rules.append(rewrite_rule)
         settings.proxy.rewrite.set_rewrite_rules(project_key.id, rewrite_rules)
     else:
         parameter_rule_filter = lambda rule: rule.name == kwargs['name'] and rule.type == kwargs['type'] and rule.modes == modes
+        url_rule_filter = lambda rule: rule.host == kwargs['host'] and rule.modes == modes
+
         for rewrite_rule in filtered_rewrite_rules:
-            parameter_rules = rewrite_rule.parameter_rules
-            filtered_parameter_rules: List[ParameterRule] = list(filter(parameter_rule_filter, parameter_rules))
+            # Parameter rules
             parameter_rule_dict = __select_parameter_rule(kwargs)
 
-            if len(filtered_parameter_rules) == 0:
-                parameter_rule = ParameterRule(parameter_rule_dict)
-                parameter_rules.append(parameter_rule)
-                rewrite_rule.parameter_rules = parameter_rules
-            else:
-                for parameter_rule in filtered_parameter_rules:
-                    parameter_rule.update(parameter_rule_dict)
+            if parameter_rule_dict:
+                parameter_rules = rewrite_rule.parameter_rules
+                filtered_parameter_rules: List[ParameterRule] = list(filter(parameter_rule_filter, parameter_rules))
+
+                if len(filtered_parameter_rules) == 0:
+                    parameter_rule = ParameterRule(parameter_rule_dict)
+                    parameter_rules.append(parameter_rule)
+                    rewrite_rule.parameter_rules = parameter_rules
+                else:
+                    for parameter_rule in filtered_parameter_rules:
+                        parameter_rule.update(parameter_rule_dict)
+
+            # URL rules
+            url_rule_dict = __select_url_rule(kwargs)
+            
+            if url_rule_dict:
+                url_rules = rewrite_rule.url_rules
+                filtered_url_rules: List[UrlRule] = list(filter(url_rule_filter, url_rules))
+
+                if len(filtered_url_rules) == 0:
+                    url_rule = UrlRule(url_rule_dict)
+                    url_rules.append(url_rule)
+                    rewrite_rule.url_rules = url_rules
+                else:
+                    for url_rule in filtered_url_rules:
+                        url_rule.update(url_rule_dict)
 
     settings.commit()
 
@@ -437,6 +474,9 @@ config.add_command(rewrite)
 config.add_command(scenario)
 
 def __select_parameter_rule(kwargs):
+    if kwargs['name'] == None or kwargs['value'] == None or kwargs['type'] == None:
+        return
+
     return {
         'modes': list(kwargs['mode']),
         'name': kwargs['name'],
@@ -444,6 +484,16 @@ def __select_parameter_rule(kwargs):
         'type': kwargs['type'],
     }
 
+def __select_url_rule(kwargs):
+    if kwargs['host'] == None or kwargs['port'] == None:
+        return
+
+    return {
+        'host': kwargs['host'],
+        'modes': list(kwargs['mode']),
+        'port': kwargs['port'],
+    }
+
 def __project_key(settings):
     project_key = settings.proxy.intercept.project_key
     validate_project_key(project_key)

stoobly_agent/app/cli/helpers/openapi_endpoint_adapter.py

@@ -1,13 +1,13 @@
 import copy
 from functools import reduce
 import itertools
-import pdb
 from pprint import pprint
 import re
 from typing import Dict, List, Union
 from urllib.parse import urlparse
 
 from openapi_core import Spec
+import yaml
 
 from stoobly_agent.lib.api.interfaces.endpoints import (
   Alias,
@@ -23,17 +23,30 @@ class OpenApiEndpointAdapter():
     return
 
   def adapt_from_file(self, file_path) -> List[EndpointShowResponse]:
-    spec = Spec.from_file_path(file_path)
+    spec = {}
+
+    with open(file_path, "r") as stream:
+      file_data: Dict = yaml.safe_load(stream)
+
+      if 'info' not in file_data:
+        self.__add_info(file_data)
+
+      missing_oauth2_scopes = self.__is_missing_oauth2_scopes(file_data)
+      if missing_oauth2_scopes:
+        self.__add_oauth2_default_scopes(file_data)
+
+      spec = Spec.from_dict(file_data)
+
     return self.adapt(spec)
 
   def adapt(self, spec: Spec) -> List[EndpointShowResponse]:
     endpoints = []
     endpoint_counter = 0
-    components = spec.get("components")
+    components = spec.get("components", {})
     schemas = components.get("schemas", {})
     paths = spec.getkey('paths')
 
-    servers_spec = spec / "servers"
+    servers_spec = spec.get("servers")
     servers = self.__evaluate_servers(servers_spec)
 
     for _, server in enumerate(servers):
@@ -177,12 +190,12 @@ class OpenApiEndpointAdapter():
           request_body = operation.get("requestBody", {})
           required_request_body = request_body.get("required")
           required_body_params = []
-          param_properties = {}
           literal_body_params = {}
           request_body_array = False
 
           content = request_body.get("content", {})
           for mimetype, media_type in content.items():
+            param_properties = {}
             schema = media_type['schema']
 
             # If Spec Component reference, look it up in components
@@ -195,12 +208,10 @@ class OpenApiEndpointAdapter():
               schema_type = schema.get('type')
               if schema_type:
                 if schema_type == 'object':
-                  param_properties = schema['properties']
+                  param_properties = schema.get('properties', {})
                 elif schema_type == 'array':
                   request_body_array = True
                   param_properties = {'tmp': schema['items']}
-              else:
-                param_properties = {}
 
             for property_key, property_value in param_properties.items():
               if property_key in required_body_params:
@@ -231,6 +242,66 @@ class OpenApiEndpointAdapter():
     
     return endpoints
 
+  def __add_info(self, file_data: Dict):
+    if 'info' in file_data:
+      return
+
+    file_data['info'] = {
+      'version': '0.0.1',
+      'title': ''
+    }
+
+  def __is_missing_oauth2_scopes(self, file_data: Dict):
+    is_missing = False
+    if 'components' in file_data:
+      components = file_data['components']
+
+      if 'securitySchemes' in components:
+        security_schemes = components['securitySchemes']
+
+        for scheme_name, scheme in security_schemes.items():
+          if scheme.get('type') == 'oauth2':
+            flows = scheme.get('flows')
+
+            if flows and flows.get('clientCredentials'):
+              scopes = flows.get('clientCredentials').get('scopes')
+
+              if scopes is None:
+                return True
+
+            break
+
+    return is_missing
+
+  def __add_oauth2_default_scopes(self, file_data: Dict):
+    if 'components' not in file_data:
+      return
+    components = file_data['components']
+
+    if 'securitySchemes' not in components:
+      return
+    security_schemes = components['securitySchemes']
+
+    oauth_security_scheme = {}
+    for scheme_name, scheme in security_schemes.items():
+      if scheme.get('type') == 'oauth2':
+        oauth_security_scheme = scheme
+        break
+
+    # If empty dict or None
+    if not oauth_security_scheme:
+      return
+
+    flows = oauth_security_scheme['flows']
+    if not flows:
+      return
+
+    client_credentials = flows['clientCredentials']
+    if not client_credentials:
+      return
+
+    client_credentials['scopes'] = {}
+
   def __get_most_recent_param(self, literal_params: dict):
     return list(literal_params)[-1] if literal_params else None
 

stoobly_agent/app/proxy/handle_mock_service.py

@@ -41,7 +41,7 @@ def handle_request_mock_generic(context: MockContext, **options: MockOptions):
         # Rewrite request with paramter rules for mock
         request: MitmproxyRequest = context.flow.request
         request_facade = MitmproxyRequestFacade(request)
-        request_facade.with_rewrite_rules(rewrite_rules).rewrite()
+        request_facade.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
 
     __mock_hook(lifecycle_hooks.BEFORE_MOCK, context)
 

stoobly_agent/app/proxy/handle_replay_service.py

@@ -28,10 +28,11 @@ def __replay_request(replay_context: ReplayContext):
     """
     intercept_settings: InterceptSettings = replay_context.intercept_settings
     rewrite_rules = intercept_settings.rewrite_rules
+
     if len(rewrite_rules) > 0:
         request: MitmproxyRequest = replay_context.flow.request
         request_facade = MitmproxyRequestFacade(request)
-        request_facade.with_rewrite_rules(rewrite_rules).rewrite()
+        request_facade.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
 
     __replay_hook(lifecycle_hooks.BEFORE_REPLAY, replay_context)
 

stoobly_agent/app/proxy/intercept_settings.py

@@ -10,7 +10,7 @@ from stoobly_agent.app.settings.constants import firewall_action, intercept_mode
 from stoobly_agent.app.settings.rewrite_rule import RewriteRule
 from stoobly_agent.app.settings.firewall_rule import FirewallRule
 from stoobly_agent.app.settings import Settings
-from stoobly_agent.app.settings.types import IgnoreRule, MatchRule, RedactRule
+from stoobly_agent.app.settings.types import IgnoreRule, MatchRule
 from stoobly_agent.config.constants import custom_headers, env_vars, mode, request_origin, test_filter
 from stoobly_agent.lib.api.keys.project_key import InvalidProjectKey, ProjectKey
 from stoobly_agent.lib.logger import Logger
@@ -154,11 +154,11 @@ class InterceptSettings:
     return self.__select_rewrite_rules(_mode)
 
   @property
-  def record_rewrite_rules(self) -> List[RedactRule]:
+  def record_rewrite_rules(self) -> List[RewriteRule]:
     return self.__select_rewrite_rules(mode.RECORD)
 
   @property
-  def mock_rewrite_rules(self) -> List[RedactRule]:
+  def mock_rewrite_rules(self) -> List[RewriteRule]:
     return self.__select_rewrite_rules(mode.MOCK)
 
   @property
@@ -210,21 +210,18 @@ class InterceptSettings:
 
     # Filter only parameters matching active intercept mode
     for rewrite_rule in self.__rewrite_rules:
-      parameter_rules = self.__select_parameter_rules(rewrite_rule, mode)
-
-      # If no parameters rules were found, then this filter rule is not applied
-      if len(parameter_rules) == 0:
-        continue
+      # If url rule applies, then update .url_rules with url_rule
+      url_rules = self.__select_url_rules(rewrite_rule)
 
-      # Build a new RewriteRule object contain only parameter rules matching intercept mode
-      rewrite_rule = RewriteRule({
-        'methods': rewrite_rule.methods,
-        'pattern': rewrite_rule.pattern,
-        'parameters_rules': [], # Has to be dict form, manually set it
-      })
-      rewrite_rule.parameter_rules = parameter_rules
+      # If parameters rules apply, then update .parameter_rules with applicable parameter_rules
+      parameter_rules = self.__select_parameter_rules(rewrite_rule, mode)
 
-      rules.append(rewrite_rule)
+      if len(url_rules) > 0 or len(parameter_rules) > 0:
+        # Build a new RewriteRule object contain only parameter rules matching intercept mode
+        rewrite_rule = RewriteRule(rewrite_rule.to_dict())
+        rewrite_rule.url_rules = url_rules
+        rewrite_rule.parameter_rules = parameter_rules
+        rules.append(rewrite_rule)
 
     return rules
 
@@ -235,6 +232,13 @@ class InterceptSettings:
       rewrite_rule.parameter_rules or []
     ))
 
+  def __select_url_rules(self, rewrite_rule: RewriteRule, mode = None):
+    mode = mode or self.mode
+    return list(filter(
+      lambda url: mode in url.modes,
+      rewrite_rule.url_rules or []
+    ))
+
   def __initialize_lifecycle_hooks(self):
     script_path = self.lifecycle_hooks_path
 

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -8,7 +8,7 @@ from typing import Callable, List
 from urllib.parse import urlparse
 
 from stoobly_agent.app.settings.constants import request_component
-from stoobly_agent.app.settings.rewrite_rule import RewriteRule, ParameterRule
+from stoobly_agent.app.settings.rewrite_rule import ParameterRule, RewriteRule, UrlRule 
 from stoobly_agent.config.constants import custom_headers
 from stoobly_agent.lib.logger import Logger, bcolors
 from stoobly_agent.lib.utils import jmespath
@@ -29,8 +29,8 @@ class MitmproxyRequestFacade(Request):
         self.request = request
         self.uri = urlparse(self.request.url)
 
-        self.__redact_rules: List[ParameterRule] = []
-        self.__rewrite_rules: List[ParameterRule] = []
+        self.__url_rules: List[UrlRule] = []
+        self.__parameter_rules: List[ParameterRule] = []
 
         self.__body = MitmproxyRequestBodyFacade(request)
 
@@ -99,41 +99,42 @@ class MitmproxyRequestFacade(Request):
         return self.request.port
 
     @property
-    def redact_rules(self) -> List[ParameterRule]:
-        return self.__redact_rules
+    def url_rules(self) -> List[ParameterRule]:
+        return self.__url_rules
     
     @property
-    def rewrite_rules(self) -> List[ParameterRule]:
-        return self.__rewrite_rules
+    def parameter_rules(self) -> List[ParameterRule]:
+        return self.__parameter_rules
 
-    def with_rewrite_rules(self, rules: List[RewriteRule]):
+    def with_parameter_rules(self, rules: List[RewriteRule]):
         if type(rules) == list:
-            self.__rewrite_rules = self.select_parameter_rules(rules)
+            self.__parameter_rules = self.select_parameter_rules(rules)
         return self 
 
-    def with_redact_rules(self, rules: List[RewriteRule]):
+    def with_url_rules(self, rules: List[RewriteRule]):
         if type(rules) == list:
-            self.__redact_rules = self.select_parameter_rules(rules)
+            self.__url_rules = self.select_url_rules(rules)
         return self
 
-    def redact(self):
-        redacts = self.__redact_rules
-        if len(redacts) != 0:
-            self.__redact_headers(redacts)
-            self.__redact_query(redacts)
-            self.__redact_content(redacts)
-
     def rewrite(self):
-        rewrites = self.__rewrite_rules
+        rewrites = self.__parameter_rules
 
         if len(rewrites) != 0:
             self.__rewrite_headers(rewrites)
             self.__rewrite_query(rewrites)
             self.__rewrite_content(rewrites)
 
+        rewrites = self.__url_rules
+
+        if len(rewrites):
+            self.__rewrite_url(rewrites)
+
+    # Find all the rules that match request url and method
+    def select_rewrite_rules(self, rules: List[RewriteRule]) -> List[RewriteRule]:
+        return list(filter(self.__is_rewrite_rule_selected, rules or []))
+
     def select_parameter_rules(self, rules: List[RewriteRule]) -> List[ParameterRule]:
-        # Find all the rules that match request url and method
-        _rules = list(filter(self.__is_parameter_rule_selected, rules or []))
+        _rules = self.select_rewrite_rules(rules)
         
         if len(_rules) == 0:
             return []
@@ -142,7 +143,17 @@ class MitmproxyRequestFacade(Request):
 
         return [item for sublist in parameter_rules for item in sublist] # flatten list
 
-    def __is_parameter_rule_selected(self, rewrite_rule: RewriteRule):
+    def select_url_rules(self, rules: List[RewriteRule]) -> List[UrlRule]:
+        _rules = self.select_rewrite_rules(rules)
+
+        if len(_rules) == 0:
+            return []
+
+        url_rules = list(map(lambda rule: rule.url_rules, _rules))
+
+        return [item for sublist in url_rules for item in sublist] # flatten list
+
+    def __is_rewrite_rule_selected(self, rewrite_rule: RewriteRule):
         pattern = rewrite_rule.pattern
 
         try:
@@ -168,6 +179,14 @@ class MitmproxyRequestFacade(Request):
         Logger.instance().info(f"{bcolors.OKCYAN}Rewriting {rewrite.type.lower()}{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
         return rewrite.value
 
+    def __rewrite_url(self, rewrites: List[UrlRule]):
+        for rewrite in rewrites:
+            if rewrite.host:
+                self.request.host = rewrite.host
+            
+            if rewrite.port:
+                self.request.port = int(rewrite.port)
+
     def __rewrite_headers(self, rewrites: List[ParameterRule]):
         self.__apply_headers(rewrites, self.__rewrite_handler)
 
@@ -177,19 +196,6 @@ class MitmproxyRequestFacade(Request):
     def __rewrite_content(self, rewrites: List[ParameterRule]):
         self.__apply_content(rewrites, self.__rewrite_handler)
 
-    def __redact_handler(self, rewrite: ParameterRule) -> str:
-        Logger.instance().debug(f"{bcolors.OKCYAN}Redacting{bcolors.ENDC} {rewrite.name}")
-        return '[REDACTED]'
-
-    def __redact_headers(self, redacts: List[ParameterRule]):
-        self.__apply_headers(redacts, self.__redact_handler)
-
-    def __redact_query(self, redacts: List[ParameterRule]):
-        self.__apply_queries(redacts, self.__redact_handler)
-
-    def __redact_content(self, redacts: List[ParameterRule]):
-        self.__apply_content(redacts, self.__redact_handler)
-
     def __apply_headers(self, rewrites: List[ParameterRule], handler: Callable):
         rewrites = list(filter(lambda rewrite: rewrite.type == request_component.HEADER, rewrites))
         self.__apply_rewrites(self.request.headers, rewrites, handler)

stoobly_agent/app/proxy/mitmproxy/response_facade.py

@@ -11,7 +11,6 @@ class MitmproxyResponseFacade(Response):
         self.content = response.raw_content
 
         self.rewrite_rules = []
-        self.rewrite_rules = []
 
     @property
     def code(self):
@@ -42,22 +41,12 @@ class MitmproxyResponseFacade(Response):
         self.response.headers['content-length'] = str(len(self.content))
 
     
-    def with_redact_rules(self, rules: RewriteRule):
-        if type(rules) == list:
-            self.rewrite_rules = rules
-
-        return self
-
     def with_rewrite_rules(self, rules: RewriteRule):
         if type(rules) == list:
             self.rewrite_rules = rules
 
         return self
 
-    # TODO
-    def redact(self):
-        pass
-    
     # TODO
     def rewrite(self):
         pass

stoobly_agent/app/proxy/record/join_request_service.py

@@ -26,7 +26,7 @@ def join_rewritten_request(flow: MitmproxyHTTPFlow, intercept_settings: Intercep
     response = MitmproxyResponseFacade(flow.response)
     rewrite_rules = intercept_settings.record_rewrite_rules
 
-    request.with_rewrite_rules(rewrite_rules).rewrite()
+    request.with_parameter_rules(rewrite_rules).with_url_rules(rewrite_rules).rewrite()
     response.with_rewrite_rules(rewrite_rules).rewrite()
 
     return join_request(request, response, intercept_settings)

stoobly_agent/app/proxy/replay/rewrite_params_service.py

@@ -1,6 +1,6 @@
 import pdb
 
-from typing import Callable, Dict, List, TypedDict, Union
+from typing import Dict, List, Union
 
 from stoobly_agent.app.proxy.replay.alias_context import AliasContext
 from stoobly_agent.app.proxy.replay.alias_resolver import AliasResolver

stoobly_agent/app/settings/rewrite_rule.py

@@ -2,6 +2,7 @@ import pdb
 
 from .parameter_rule import ParameterRule
 from .types.proxy_settings import RewriteRule as IRewriteRule
+from .url_rule import UrlRule
 
 class RewriteRule:
 
@@ -14,6 +15,9 @@ class RewriteRule:
     self.__raw_parameter_rules = self.__rewrite_rule.get('parameter_rules') or []
     self.__parameter_rules = list(map(lambda rule: ParameterRule(rule), self.__raw_parameter_rules))
 
+    self.__raw_url_rules = self.__rewrite_rule.get('url_rules') or []
+    self.__url_rules = list(map(lambda rule: UrlRule(rule), self.__raw_url_rules))
+
   @property 
   def methods(self):
     return self.__methods
@@ -30,9 +34,18 @@ class RewriteRule:
   def parameter_rules(self, v):
     self.__parameter_rules = v
 
+  @property
+  def url_rules(self):
+    return self.__url_rules
+
+  @url_rules.setter
+  def url_rules(self, v):
+    self.__url_rules = v
+
   def to_dict(self):
     return {
       'methods': self.__methods,
       'pattern': self.__pattern,
       'parameter_rules': list(map(lambda parameter: parameter.to_dict(), self.__parameter_rules)),
+      'url_rules': list(map(lambda url: url.to_dict(), self.__url_rules)),
     }

stoobly_agent/app/settings/types/__init__.py

@@ -23,11 +23,6 @@ class IgnoreRule(TypedDict):
     method: str
     pattern: str
 
-class RedactRule(TypedDict):
-    redacts: List[Redact]
-    method: str
-    pattern: str
-
 class RewriteRule(TypedDict):
     rewrites: List[Rewrite]
     method: str
@@ -97,4 +92,4 @@ Component = {
     'QueryParam': 'Query Param',
 }
 IProjectModeSettings = Union[IProjectMockSettings, IProjectRecordSettings, IProjectTestSettings]
-Rule = Union[IgnoreRule, RedactRule, RewriteRule]
+Rule = Union[IgnoreRule, RewriteRule]

stoobly_agent/app/settings/types/proxy_settings.py

@@ -15,6 +15,11 @@ class ParameterRule(TypedDict):
   type: str
   value: str
 
+class UrlRule(TypedDict):
+  host: str
+  modes: List[Mode]
+  port: str
+
 class DataRules(TypedDict):
   mock_policy: MockPolicy
   record_policy: RecordPolicy
@@ -30,6 +35,7 @@ class RewriteRule(TypedDict):
   methods: List[Method]
   pattern: str
   parameter_rules: List[ParameterRule]
+  url_rule: List[UrlRule]
 
 class FirewallRule(TypedDict):
   action: List[FirewallAction]

stoobly_agent/app/settings/url_rule.py

@@ -0,0 +1,33 @@
+from typing import List
+
+from .types.proxy_settings import UrlRule as IUrlRule
+
+class UrlRule:
+
+  def __init__(self, url_rule: IUrlRule):
+    self.update(url_rule)
+
+  @property
+  def host(self):
+    return self.__host
+
+  @property 
+  def modes(self):
+    return self.__modes
+
+  @property
+  def port(self):
+    return self.__port
+
+  def update(self, url_rule: IUrlRule):
+    self.__url_rule = url_rule
+    self.__host = self.__url_rule.get('host')
+    self.__modes = self.__url_rule.get('modes')
+    self.__port = self.__url_rule.get('port')
+
+  def to_dict(self):
+    return {
+      'host': self.__host,
+      'modes': self.__modes,
+      'port': self.__port,
+    }