stoobly-agent 0.21.2__py3-none-any.whl → 0.22.3__py3-none-any.whl

stoobly_agent/app/proxy/mitmproxy/flow_mock.py

@@ -0,0 +1,35 @@
+import requests
+
+from mitmproxy.http import Request as MitmproxyRequest, Response as MitmproxyResponse
+from typing import Union
+
+from stoobly_agent.app.models.adapters.python import PythonRequestAdapterFactory, PythonResponseAdapterFactory
+from stoobly_agent.app.models.adapters.raw_http_request_adapter import DEFAULT_HTTP_VERSION
+
+class MitmproxyFlowMock():
+
+  def __init__(self):
+    self.__request: MitmproxyRequest = None
+    self.__response: MitmproxyResponse = None
+
+  @property
+  def request(self):
+    return self.__request
+
+  @property
+  def response(self):
+    return self.__response
+
+  @request.setter
+  def request(self, _request: Union[MitmproxyRequest, requests.Request]):
+    if isinstance(_request, requests.Request):
+      self.__request = PythonRequestAdapterFactory(_request).mitmproxy_request(DEFAULT_HTTP_VERSION)
+    else:
+      self.__request = _request
+
+  @response.setter
+  def response(self, _response: Union[MitmproxyResponse, requests.Response]):
+    if isinstance(_response, requests.Response):
+      self.__response = PythonResponseAdapterFactory(_response).mitmproxy_response()
+    else:
+      self.__response = _response

stoobly_agent/app/proxy/mitmproxy/request_facade.py

@@ -5,6 +5,7 @@ from mitmproxy.http import Headers, Request as MitmproxyRequest
 from mitmproxy.coretypes import multidict
 from typing import Callable, List, Union
 from urllib.parse import urlparse
+import requests
 
 from stoobly_agent.app.settings.constants import request_component
 from stoobly_agent.app.settings.rewrite_rule import RewriteRule, ParameterRule
@@ -53,7 +54,7 @@ class MitmproxyRequestFacade(Request):
 
     @property
     def body(self):
-        content = self.request.raw_content
+        content = self.request.raw_content or ''
 
         try:
             if isinstance(content, bytes):
@@ -96,6 +97,14 @@ class MitmproxyRequestFacade(Request):
     def rewrite_rules(self) -> List[ParameterRule]:
         return self.__rewrite_rules
 
+    def to_python_request(self):
+        return requests.Request(
+            method=self.request.method,
+            url=self.request.url,
+            headers=self.request.headers,
+            data=self.request.content
+        )
+
     def with_rewrite_rules(self, rules: List[RewriteRule]):
         if type(rules) == list:
             self.__rewrite_rules = self.select_parameter_rules(rules)
@@ -154,7 +163,7 @@ class MitmproxyRequestFacade(Request):
             })
 
     def __rewrite_handler(self, rewrite: ParameterRule) -> str:
-        Logger.instance().debug(f"{bcolors.OKCYAN}Rewriting{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
+        Logger.instance().info(f"{bcolors.OKCYAN}Rewriting {rewrite.type.lower()}{bcolors.ENDC} {rewrite.name} => {rewrite.value}")
         return rewrite.value
 
     def __rewrite_headers(self, rewrites: List[ParameterRule]):

stoobly_agent/app/proxy/replay/replay_request_service.py

@@ -5,16 +5,17 @@ import requests
 from http.cookies import SimpleCookie
 from typing import Callable, TypedDict, Union
 
+from stoobly_agent.app.cli.ca_cert_installer import CACertInstaller
 from stoobly_agent.app.cli.helpers.context import ReplayContext
 from stoobly_agent.app.models.schemas.request import Request
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
 from stoobly_agent.app.proxy.mitmproxy.request_facade import MitmproxyRequestFacade
 from stoobly_agent.app.proxy.replay.trace_context import TraceContext
+from stoobly_agent.app.proxy.simulate_intercept_service import simulate_intercept
 from stoobly_agent.app.settings import Settings
 from stoobly_agent.config.constants import alias_resolve_strategy, custom_headers, request_origin, test_filter, test_strategy
 from stoobly_agent.config.mitmproxy import MitmproxyConfig
-from stoobly_agent.config.constants import mode
-from stoobly_agent.lib.api.api import Api
+from stoobly_agent.config.constants import mock_policy, mode
 
 class ReplayRequestOptions(TypedDict):
   alias_resolve_strategy: alias_resolve_strategy.AliasResolveStrategy
@@ -25,6 +26,7 @@ class ReplayRequestOptions(TypedDict):
   before_replay: Union[Callable[[ReplayContext], None], None]
   after_replay: Union[Callable[[ReplayContext], Union[requests.Response, None]], None]
   project_key: Union[str, None]
+  proxies: dict
   report_key: Union[str, None] 
   request_origin: Union[request_origin.CLI, None] 
   scenario_key: Union[str, None] 
@@ -37,17 +39,14 @@ def replay_with_trace(context: ReplayContext, trace_context: TraceContext, optio
   trace_context.alias_resolve_strategy = options.get('alias_resolve_strategy')
   return trace_context.with_replay_context(context, lambda context: replay(context, options))
 
-def replay_with_rewrite(context: ReplayContext) -> requests.Response:
-  return replay(context, {
-      'before_replay': __handle_before_replay
-  })
-
 def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Response:
   if 'before_replay' in options and callable(options['before_replay']):
     options['before_replay'](context)
 
   request = context.request
   headers = request.headers
+  method = request.method
+  cookies = __get_cookies(headers)
 
   if options.get('host'):
     request.host = options['host']
@@ -56,48 +55,70 @@ def replay(context: ReplayContext, options: ReplayRequestOptions) -> requests.Re
   if options.get('scheme'):
     request.scheme = options['scheme']
 
-  if 'alias_resolve_strategy' in options:
+  if options.get('alias_resolve_strategy'):
     headers[custom_headers.ALIAS_RESOLVE_STRATEGY] = options['alias_resolve_strategy']
 
-  if 'lifecycle_hooks_script_path' in options:
+  if options.get('lifecycle_hooks_script_path'):
     __handle_lifecycle_hooks_script_path(options['lifecycle_hooks_script_path'], headers) 
 
-  if 'mode' in options:
+  if options.get('mode'):
     __handle_mode_option(options['mode'], request, headers)
 
-  if 'project_key' in options:
+  if options.get('project_key'):
     headers[custom_headers.PROJECT_KEY] = options['project_key']
 
-  if 'report_key' in options:
+  if options.get('report_key'):
     headers[custom_headers.REPORT_KEY] = options['report_key']
 
-  if 'request_origin' in options:
+  if options.get('request_origin'):
     headers[custom_headers.REQUEST_ORIGIN] = options['request_origin']
 
-  if 'scenario_key' in options:
+  if options.get('scenario_key'):
     headers[custom_headers.SCENARIO_KEY] = options['scenario_key']
 
-  if 'test_filter' in options:
+  if options.get('test_filter'):
     headers[custom_headers.TEST_FILTER] = options['test_filter']
 
-  if 'test_strategy' in options:
+  if options.get('test_strategy'):
     headers[custom_headers.TEST_STRATEGY] = options['test_strategy']
 
-  method = request.method
-  handler = getattr(requests, method.lower())
-  cookies = __get_cookies(request.headers)
-
-  # Set proxy env vars to ensure request gets sent to proxy
-  res: requests.Response = Api().with_proxy(lambda: handler(
-    request.url, 
-    allow_redirects = True,
-    cookies = cookies,
-    data=request.body,
-    headers=headers, 
-    #params=request.query_params, # Do not send query params, they should be a part of the URL
-    stream = True,
-    verify = not MitmproxyConfig.instance().get('ssl_insecure')
-  ))
+  request_config = {
+    'allow_redirects': True,
+    'stream': True,
+    'verify': not MitmproxyConfig.instance().get('ssl_insecure')
+  }
+  request_dict = {
+    'cookies': cookies,
+    'data': request.body,
+    'headers': headers, 
+    #'params': request.query_params, # Do not send query params, they should be a part of the URL
+  }
+
+  res: requests.Response = None
+  if not options.get('proxy'):
+    request = requests.Request(**{
+      **request_dict,
+      'method': method,
+      'url': request.url,
+    })
+
+    res = simulate_intercept(request, **request_config)
+  else:
+    settings = Settings.instance()
+    handler = getattr(requests, method.lower())
+
+    res = handler(
+      request.url, 
+      **{
+        **request_config,
+        **request_dict,
+        'proxies': {
+          'http': settings.proxy.url,
+          'https': settings.proxy.url,
+        },
+        'verify': CACertInstaller().mitm_crt_absolute_path if request_config['verify'] else False,
+      }
+    )
 
   if 'after_replay' in options and callable(options['after_replay']):
     context.with_response(res)
@@ -119,7 +140,10 @@ def __handle_mode_option(_mode, request: Request, headers):
 
   if _mode == mode.MOCK or _mode == mode.TEST:
     # If mocking or testing, we already know which request to get response from 
-    headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+    if request.id:
+      headers[custom_headers.MOCK_REQUEST_ID] = str(request.id)
+
+    headers[custom_headers.MOCK_POLICY] = mock_policy.ALL
   elif _mode == mode.RECORD:
     # If recording, then it's actually a replay and record
     headers[custom_headers.PROXY_MODE] = mode.REPLAY
@@ -127,11 +151,4 @@ def __handle_mode_option(_mode, request: Request, headers):
 
 def __get_cookies(headers: Request.headers):
   cookies = SimpleCookie(headers.get('Cookie')).items()
-  return {k: v.value for k, v in cookies}
-
-def __handle_before_replay(context: ReplayContext):
-  request = context.request
-  request_facade = MitmproxyRequestFacade(request)
-  intercept_settings = InterceptSettings(Settings.instance())
-  rewrite_rules = intercept_settings.replay_rewrite_rules
-  request_facade.with_rewrite_rules(rewrite_rules).rewrite()
+  return {k: v.value for k, v in cookies}

stoobly_agent/app/proxy/simulate_intercept_service.py

@@ -0,0 +1,30 @@
+import pdb
+import requests
+
+from mitmproxy.http import Request as MitmproxyRequest
+
+from stoobly_agent.app.proxy.mitmproxy.flow_mock import MitmproxyFlowMock
+from stoobly_agent.app.models.adapters.mitmproxy import MitmproxyRequestAdapterFactory, MitmproxyResponseAdapterFactory
+
+from .intercept_handler import request as handle_request, response as handle_response
+
+def simulate_intercept(request: requests.Request, **config):
+  flow = MitmproxyFlowMock()
+
+  flow.request = request
+
+  handle_request(flow)
+
+  if not flow.response:
+    session = requests.Session()
+    prepared_request = __prepare_mitmproxy_request(flow.request)
+    res = session.send(prepared_request, **config)
+    flow.response = res
+
+  handle_response(flow)
+
+  return MitmproxyResponseAdapterFactory(flow.response).python_response()
+
+def __prepare_mitmproxy_request(request: MitmproxyRequest) -> requests.Request:
+  _request = MitmproxyRequestAdapterFactory(request).python_request()
+  return _request.prepare()

stoobly_agent/app/proxy/test/__init__.py

@@ -1,2 +1,3 @@
 from .context import TestContext
+from .context_abc import TestContextABC
 from .context_response import TestContextResponse

stoobly_agent/app/proxy/test/context.py

@@ -20,10 +20,11 @@ from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
 from stoobly_agent.lib.orm.trace import Trace
 
 from .context_response import TestContextResponse
+from .context_abc import TestContextABC
 
 FuzzyContent = Union[dict, list, str]
 
-class TestContext():
+class TestContext(TestContextABC):
   def __init__(self, replay_context: ReplayContext, mock_context: MockContext):
     self.__flow = mock_context.flow
     self.__intercept_settings = mock_context.intercept_settings

stoobly_agent/app/proxy/test/context_abc.py

@@ -0,0 +1,155 @@
+import abc
+
+from mitmproxy.http import Request
+from typing import Union
+
+from stoobly_agent.app.proxy.test.helpers.endpoint_facade import EndpointFacade
+from stoobly_agent.app.proxy.test.helpers.request_component_names_facade import RequestComponentNamesFacade
+
+from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
+from stoobly_agent.lib.orm.trace import Trace
+
+from .context_response import TestContextResponse
+
+FuzzyContent = Union[dict, list, str]
+
+class TestContextABC(abc.ABC):
+
+  @abc.abstractmethod
+  def with_endpoints_resource(self, resource: EndpointShowResponse):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def cached_expected_response_content(self) -> Union[bytes, None, str]:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def endpoint(self) -> EndpointFacade:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def lifecycle_hooks(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def lifecycle_hooks_script_path(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def end_time(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def expected_response(self) -> TestContextResponse:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def decoded_response_content(self) -> FuzzyContent:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def decoded_expected_response_content(self) -> FuzzyContent:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def filter(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def flow(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def intercept_settings(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def log(self):
+    pass
+
+  @log.setter
+  @abc.abstractmethod
+  def log(self, v: str):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def mock_request_id(self) -> Union[str, None]:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def mock_request_endpoint_id(self) -> Union[str, None]:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def passed(self):
+    pass
+
+  @passed.setter
+  @abc.abstractmethod
+  def passed(self, v):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def request(self) -> Request:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def request_headers(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def response(self) -> TestContextResponse:
+    pass
+
+  @property
+  @abc.abstractmethod
+  def response_param_names(self) -> RequestComponentNamesFacade: 
+    pass
+
+  @property
+  @abc.abstractmethod
+  def rewritten_expected_response_content(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def skipped(self):
+    pass
+
+  @skipped.setter
+  @abc.abstractmethod
+  def skipped(self, v: bool):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def start_time(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def strategy(self):
+    pass
+
+  @property
+  @abc.abstractmethod
+  def trace(self) -> Union[Trace, None]:
+    pass

stoobly_agent/app/proxy/test/matchers/context.py

@@ -2,7 +2,7 @@ import pdb
 
 from typing import Iterable, List, TypedDict, Union
 
-from stoobly_agent.app.proxy.test.context import TestContext
+from stoobly_agent.app.proxy.test.context_abc import TestContextABC as TestContext
 from stoobly_agent.app.proxy.test.helpers.request_component_names_facade import RequestComponentNamesFacade
 from stoobly_agent.lib.api.interfaces.endpoints import RequestComponentName, ResponseParamName
 from stoobly_agent.lib.utils.python_to_ruby_type import convert

stoobly_agent/app/proxy/test/matchers/contract.py

@@ -5,7 +5,7 @@ from typing import List, Tuple, TypedDict, Union
 from stoobly_agent.app.proxy.test.helpers.request_component_names_facade import RequestComponentNamesFacade
 from stoobly_agent.lib.api.interfaces.endpoints import RequestComponentName
 
-from ..context import TestContext
+from ..context_abc import TestContextABC as TestContext
 from .context import MatchContext, build_match_context
 from .errors import length_match_error, param_name_exists_error, param_name_missing_error, type_match_error, valid_type_error
 

stoobly_agent/app/proxy/test/matchers/custom.py

@@ -1,4 +1,4 @@
-from stoobly_agent.app.proxy.test.context import TestContext
+from stoobly_agent.app.proxy.test.context_abc import TestContextABC as TestContext
 
 def matches(context: TestContext):
     lifecycle_hooks = context.lifecycle_hooks 

stoobly_agent/app/proxy/test/matchers/diff.py

@@ -1,7 +1,7 @@
 import pdb
 
 from typing import Tuple
-from stoobly_agent.app.proxy.test.context import TestContext
+from stoobly_agent.app.proxy.test.context_abc import TestContextABC as TestContext
 
 from stoobly_agent.app.proxy.test.helpers.request_component_names_facade import RequestComponentNamesFacade
 from stoobly_agent.app.proxy.test.matchers.errors import length_match_error, param_name_missing_error, type_match_error, value_match_error

stoobly_agent/app/proxy/test/matchers/fuzzy.py

@@ -1,7 +1,7 @@
 import pdb
 
 from typing import Iterable, Tuple
-from stoobly_agent.app.proxy.test.context import TestContext
+from stoobly_agent.app.proxy.test.context_abc import TestContextABC as TestContext
 from stoobly_agent.app.proxy.test.helpers.request_component_names_facade import RequestComponentNamesFacade
 from stoobly_agent.app.proxy.test.matchers.errors import param_name_missing_error, type_match_error, valid_type_error
 

stoobly_agent/app/proxy/test/test_service.py

@@ -4,7 +4,7 @@ from stoobly_agent.app.proxy.replay.body_parser_service import decode_response,
 
 from stoobly_agent.config.constants import test_strategy
 
-from .context import TestContext
+from .context_abc import TestContextABC as TestContext
 from .matchers.custom import matches as custom_matches
 from .matchers.contract import matches as contract_matches
 from .matchers.diff import matches as diff_matches

stoobly_agent/app/proxy/upload/joined_request.py

@@ -53,5 +53,4 @@ class JoinedRequest:
         response_string = self.__response_string.get(control=True)
 
         joined = self.REQUEST_DELIMITTER.join([request_string, response_string])
-
         return joined

stoobly_agent/app/proxy/upload/proxy_request.py

@@ -1,7 +1,7 @@
 from ..mitmproxy.request_facade import MitmproxyRequestFacade
 
 class ProxyRequest:
-    def __init__(self, request: MitmproxyRequestFacade, upstream_url: str):
+    def __init__(self, request: MitmproxyRequestFacade, upstream_url: str = None):
         self.request = request
 
         self.upstream_url = upstream_url
@@ -9,4 +9,7 @@ class ProxyRequest:
     def url(self):
         url = self.request.url
 
+        if not self.upstream_url:
+            return url
+
         return url.replace(self.request.base_url, self.upstream_url)

stoobly_agent/app/proxy/upload/request_string.py

@@ -74,7 +74,7 @@ class RequestString:
         toks = header.split('_')
 
         for index, tok in enumerate(toks):
-            toks[index] = tok.lower().capitalize()
+            toks[index] = tok.lower().title()
 
         return "-".join(toks)
 

stoobly_agent/app/settings/constants/mode.py

@@ -0,0 +1,3 @@
+TEST = 'test'
+DEVELOPMENT = 'development'
+PRODUCTION = 'production'

stoobly_agent/cli.py

@@ -1,16 +1,21 @@
 import click
 import os
 import pdb
+import requests
 import sys
 
 from stoobly_agent import VERSION
-from stoobly_agent.config.constants import env_vars
+from stoobly_agent.app.cli.helpers.context import ReplayContext
+from stoobly_agent.app.cli.helpers.handle_mock_service import print_raw_response, RAW_FORMAT
+from stoobly_agent.app.proxy.constants import custom_response_codes
+from stoobly_agent.app.proxy.replay.replay_request_service import replay as replay_request
+from stoobly_agent.config.constants import env_vars, mode
 from stoobly_agent.config.data_dir import DataDir
 from stoobly_agent.lib.utils.conditional_decorator import ConditionalDecorator
 
 from .app.api import run as run_api
 from .app.cli import ca_cert, config, feature, intercept, MainGroup, request, scenario, trace
-from .app.proxy import CONNECTION_STRATEGIES, INTERCEPT_MODES, run as run_proxy
+from .app.proxy import CONNECTION_STRATEGIES, run as run_proxy
 from .app.settings import Settings
 from .lib import logger
 from .lib.orm.migrate_service import migrate as migrate_database
@@ -67,7 +72,6 @@ def init(**kwargs):
 @ConditionalDecorator(lambda f: click.option('--api-url', help='API URL.')(f), is_remote)
 @click.option('--headless', is_flag=True, default=False, help='Disable starting UI.')
 @click.option('--connection-strategy', help=', '.join(CONNECTION_STRATEGIES), type=click.Choice(CONNECTION_STRATEGIES))
-@click.option('--intercept-mode', help=', '.join(INTERCEPT_MODES), type=click.Choice(INTERCEPT_MODES))
 @click.option('--log-level', default=logger.INFO, type=click.Choice([logger.DEBUG, logger.INFO, logger.WARNING, logger.ERROR]), help='''
     Log levels can be "debug", "info", "warning", or "error"
 ''')
@@ -94,8 +98,73 @@ def run(**kwargs):
     if 'headless' in kwargs and not kwargs['headless']:
         run_api(**kwargs)
 
-    if kwargs['intercept_mode'] and kwargs['intercept_mode'] not in INTERCEPT_MODES:
-        print(f"Error: Invalid value for --intercept-mode, values: {', '.join(INTERCEPT_MODES)}", file=sys.stderr)
-        sys.exit(1)
+    run_proxy(**kwargs)
 
-    run_proxy(**kwargs)
+@main.command(
+  help="Mock request"
+)
+@click.option('-d', '--data', default='', help='HTTP POST data')
+@click.option('--format', type=click.Choice([RAW_FORMAT]), help='Format response')
+@click.option('-H', '--header', multiple=True, help='Pass custom header(s) to server')
+@ConditionalDecorator(lambda f: click.option('--project-key')(f), is_remote)
+@click.option('-X', '--request', default='GET', help='Specify request command to use')
+@click.option('--scenario-key')
+@click.argument('url')
+def mock(**kwargs):
+  request = __build_request_from_curl(**kwargs)
+
+  context = ReplayContext.from_python_request(request)
+  response: requests.Response = replay_request(context, {
+    **kwargs,
+    'mode': mode.MOCK,
+  })
+
+  if response.status_code == custom_response_codes.NOT_FOUND:
+    print(f"Error: {response.content.decode()}")
+    sys.exit(1)
+
+  if kwargs['format'] == RAW_FORMAT:
+    print_raw_response(response)
+  else:
+    print(response.content.decode())
+
+@main.command(
+  help="Record request"
+)
+@click.option('-d', '--data', default='', help='HTTP POST data')
+@click.option('--format', type=click.Choice([RAW_FORMAT]), help='Format response')
+@click.option('-H', '--header', multiple=True, help='Pass custom header(s) to server')
+@ConditionalDecorator(lambda f: click.option('--project-key')(f), is_remote)
+@click.option('-X', '--request', default='GET', help='Specify request command to use')
+@click.option('--scenario-key')
+@click.argument('url')
+def record(**kwargs):
+  request = __build_request_from_curl(**kwargs)
+
+  context = ReplayContext.from_python_request(request)
+  response: requests.Response = replay_request(context, {
+    **kwargs,
+    'mode': mode.RECORD,
+  })
+
+  if kwargs['format'] == RAW_FORMAT:
+    print_raw_response(response)
+  else:
+    print(response.content.decode())
+
+def __build_request_from_curl(**kwargs):
+  headers = {}
+  for header in kwargs['header']:
+    toks = header.split(':')
+
+    if len(toks) != 2:
+      continue
+    
+    headers[toks[0]] = toks[1]
+
+  return requests.Request(
+    data=kwargs['data'],
+    headers=headers,
+    method=kwargs['request'],
+    url=kwargs['url']
+  )

stoobly_agent/config/constants/env_vars.py

@@ -1,8 +1,9 @@
 AGENT_ACTIVE_MODE = 'STOOBLY_AGENT_ACTIVE_MODE'
 AGENT_CONFIG_PATH = 'STOOBLY_AGENT_CONFIG_PATH'
 AGENT_ENABLED = 'STOOBLY_AGENT_ENABLED'
-AGENT_IS_HEADLESS = 'STOOBLY_AGENT_IS_HEADLESS'
+AGENT_SELF_INTERCEPT_ENABLED = 'STOOBLY_AGENT_SELF_INTERCEPT_ENABLED'
 AGENT_INCLUDE_PATTERNS = 'STOOBLY_AGENT_INCLUDE_PATTERNS'
+AGENT_IS_HEADLESS = 'STOOBLY_AGENT_IS_HEADLESS'
 AGENT_EXCLUDE_PATTERNS = 'STOOBLY_AGENT_EXCLUDE_PATTERNS'
 AGENT_POLICY = 'STOOBLY_AGENT_POLICY'
 AGENT_PROJECT_KEY = 'STOOBLY_AGENT_PROJECT_KEY'