stoobly-agent 1.9.12__py3-none-any.whl → 1.10.0__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '1.9.12'
+VERSION = '1.10.0'

stoobly_agent/app/api/__init__.py

@@ -5,7 +5,6 @@ import threading
 from http.server import HTTPServer
 from urllib.parse import urlparse
 
-from stoobly_agent.app.settings import Settings
 from stoobly_agent.config.constants import env_vars
 from stoobly_agent.lib.logger import Logger
 
@@ -17,22 +16,7 @@ def start_server(host, port):
     httpd = HTTPServer((host, port), ApplicationHTTPRequestHandler)
     httpd.serve_forever()
 
-def initialize(**kwargs):
-    url = f"http://{kwargs['ui_host']}:{kwargs['ui_port']}"
-
-    os.environ[env_vars.AGENT_URL] = url
-
-    # TODO: debug why the following is needed or else logger won't print
-    settings = Settings.instance()
-    settings.ui.url = url
-    settings.commit()
-
-    return url
-
-def run(url):
-    parsed_url = urlparse(url)
-
-    Logger.instance(LOG_ID).info(f"Server listening at {url}\n")
-
-    thread = threading.Thread(target=start_server, args=(parsed_url.hostname, parsed_url.port))
-    thread.start()
+def run(**kwargs):
+    Logger.instance(LOG_ID).info(f"starting and listening at {kwargs['ui_host']}:{kwargs['ui_port']}")
+    thread = threading.Thread(target=start_server, args=(kwargs['ui_host'], kwargs['ui_port']))
+    return thread.start()

stoobly_agent/app/api/configs_controller.py

@@ -4,7 +4,7 @@ from mergedeep import merge
 
 from stoobly_agent.app.api.simple_http_request_handler import SimpleHTTPRequestHandler
 from stoobly_agent.app.cli.helpers.handle_config_update_service import (
-    context as handle_context, handle_intercept_active_update, handle_order_update, handle_project_update, handle_scenario_update
+    context as handle_context, handle_intercept_active_update, handle_order_update, handle_project_update, handle_scenario_update, handle_strategy_update
 ) 
 from stoobly_agent.app.models.scenario_model import ScenarioModel
 from stoobly_agent.app.proxy.intercept_settings import InterceptSettings
@@ -61,7 +61,7 @@ class ConfigsController:
 
     # GET /configs/summary
     def summary(self, context):
-        settings = Settings.instance()
+        settings: Settings = Settings.instance()
         proxy = settings.proxy
         intercept_settings = InterceptSettings(settings)
 
@@ -94,7 +94,6 @@ class ConfigsController:
                 'mode': intercept_settings.mode,
                 'modes': modes,
                 'project_id': int(project_id) if project_id != None else None,
-                'proxy_url': proxy.url,
                 'remote_enabled': settings.cli.features.remote,
                 'remote_project_id': remote_project_id,
                 'scenario_id': int(scenario_id) if scenario_id != None else None,
@@ -113,6 +112,7 @@ class ConfigsController:
 
         handle_intercept_active_update(settings, _handle_context)
         handle_order_update(settings, _handle_context)
+        handle_strategy_update(settings, _handle_context)
         handle_project_update(settings, _handle_context)
         handle_scenario_update(settings, _handle_context)
 

stoobly_agent/app/cli/decorators/exec.py

@@ -19,7 +19,7 @@ class ExecDecorator():
         shell = kwargs['shell']
         file_path = kwargs['file_path']
 
-        settings = Settings.instance()
+        settings: Settings = Settings.instance()
         proxy_url = settings.proxy.url
 
         if not proxy_url:

stoobly_agent/app/cli/helpers/handle_config_update_service.py

@@ -127,6 +127,10 @@ def handle_order_update(new_settings: Settings, context: Context = None):
         scenario_model = ScenarioModel(new_settings)
         scenario_model.update(_scenario_key.id, **{ 'overwritable': False })[1]
 
+def handle_strategy_update(new_settings: Settings, context: Context = None):
+  # Handle side effects here
+  pass
+
 def __current_proxy_settings(context: Context = None):
   if context and context.get('current_proxy_settings'):
     return context['current_proxy_settings']

stoobly_agent/app/cli/intercept_cli.py

@@ -3,27 +3,27 @@ import pdb
 import sys
 
 from stoobly_agent.app.settings import Settings
-from stoobly_agent.config.constants import mode, mock_policy, record_order, record_policy, replay_policy
+from stoobly_agent.config.constants import mode, mock_policy, record_order, record_policy, record_strategy, replay_policy, test_strategy
 from stoobly_agent.lib.api.keys.project_key import ProjectKey
 
-from .helpers.handle_config_update_service import handle_intercept_active_update, handle_order_update
+from .helpers.handle_config_update_service import handle_intercept_active_update, handle_order_update, handle_strategy_update
 
 settings: Settings = Settings.instance()
 
-mode_options = [mode.MOCK, mode.RECORD, mode.REPLAY]
+mode_options = [mode.MOCK, mode.RECORD, mode.REPLAY, mode.TEST]
 
 if settings.cli.features.remote:
     mode_options.append(mode.TEST)
 
 active_mode = settings.proxy.intercept.mode
 
-def __get_order_options(active_mode):
+def __get_order_options(active_mode: str) -> list[str]:
     if active_mode == mode.RECORD:
         return [record_order.APPEND, record_order.OVERWRITE]
     else:
         return []
 
-def __get_policy_options(active_mode):
+def __get_policy_options(active_mode: str) -> list[str]:
     if active_mode == mode.MOCK:
         return [mock_policy.ALL, mock_policy.FOUND]
     elif active_mode == mode.RECORD:
@@ -35,8 +35,17 @@ def __get_policy_options(active_mode):
     else:
         return []
 
+def __get_strategy_options(active_mode: str) -> list[str]:
+    if active_mode == mode.RECORD:
+        return [record_strategy.FULL, record_strategy.MINIMAL]
+    elif active_mode == mode.TEST:
+        return [test_strategy.CONTRACT, test_strategy.CUSTOM, test_strategy.DIFF, test_strategy.FUZZY]
+    else:
+        return []
+
 order_options = __get_order_options(active_mode)
 policy_options = __get_policy_options(active_mode)
+strategy_options = __get_strategy_options(active_mode)
 
 @click.group(
     epilog="Run 'stoobly-agent intercept COMMAND --help' for more information on a command.",
@@ -80,10 +89,11 @@ def disable(**kwargs):
 @click.option('--mode', type=click.Choice(mode_options))
 @click.option('--order', type=click.Choice(order_options))
 @click.option('--policy', type=click.Choice(policy_options))
+@click.option('--strategy', type=click.Choice(strategy_options))
 def configure(**kwargs):
     settings: Settings = Settings.instance()
 
-    if not kwargs['mode'] and not kwargs['order'] and not kwargs['policy']:
+    if not kwargs['mode'] and not kwargs['order'] and not kwargs['policy'] and not kwargs['strategy']:
         print("Error: Missing an option")
         sys.exit(1)
 
@@ -136,6 +146,26 @@ def configure(**kwargs):
 
         print(f"Updating {_mode} policy to {kwargs['policy']}")
 
+    if kwargs['strategy']:
+        active_mode = settings.proxy.intercept.mode
+
+        if active_mode == mode.RECORD or active_mode == mode.TEST:
+            project_key = ProjectKey(settings.proxy.intercept.project_key)
+            data_rule = settings.proxy.data.data_rules(project_key.id)
+
+            if active_mode == mode.RECORD:
+                data_rule.record_strategy = kwargs['strategy']
+            elif active_mode == mode.TEST:
+                data_rule.test_strategy = kwargs['strategy']
+        else:
+            print("Error: set --strategy to a intercept mode that supports the strategy option", file=sys.stderr)
+            sys.exit(1)
+
+        handle_strategy_update(settings)
+
+        print(f"Updating {_mode} policy to {kwargs['strategy']}")
+
+
     settings.commit()
 
 @intercept.command(
@@ -148,17 +178,20 @@ def show(**kwargs):
     project_key = ProjectKey(settings.proxy.intercept.project_key)
     data_rule = settings.proxy.data.data_rules(project_key.id)
     policy = None
+    strategy = None
 
     if active_mode == mode.MOCK:
         policy = data_rule.mock_policy
     elif active_mode == mode.RECORD:
         policy = data_rule.record_policy
+        strategy = data_rule.record_strategy
     elif active_mode == mode.REPLAY:
         policy = data_rule.replay_policy
     elif active_mode == mode.TEST:
         policy = data_rule.test_policy
+        strategy = data_rule.test_strategy
 
     if not _mode:
         print('No intercept mode set')
     else:
-        print(f"{_mode.capitalize()} with policy {policy} {'enabled' if settings.proxy.intercept.active else 'disabled'}")
+        print(f"{_mode.capitalize()} with policy: '{policy}', strategy: '{strategy}', {'enabled' if settings.proxy.intercept.active else 'disabled'}")

stoobly_agent/app/cli/scaffold/app_command.py

@@ -56,6 +56,10 @@ class AppCommand(Command):
   def data_dir_path(self):
     return self.app.data_dir_path
 
+  @property
+  def plugins_root_dir(self):
+    return os.path.join(self.templates_root_dir, 'plugins')
+
   @property
   def scaffold_namespace_path(self):
     return self.app.scaffold_namespace_path

stoobly_agent/app/cli/scaffold/app_config.py

@@ -1,5 +1,7 @@
+import os
+
 from .config import Config
-from .constants import APP_DOCKER_SOCKET_PATH_ENV, APP_NAME_ENV, APP_UI_PORT_ENV
+from .constants import APP_DOCKER_SOCKET_PATH_ENV, APP_NAME_ENV, APP_NETWORK_ENV, APP_PLUGINS_DELMITTER, APP_PLUGINS_ENV, APP_UI_PORT_ENV
 
 class AppConfig(Config):
 
@@ -8,6 +10,7 @@ class AppConfig(Config):
 
     self.__docker_socket_path = '/var/run/docker.sock'
     self.__name = None
+    self.__plugins = None
     self.__ui_port = None
 
     self.load()
@@ -28,6 +31,14 @@ class AppConfig(Config):
   def name(self, v):
     self.__name = v
 
+  @property
+  def plugins(self):
+    return self.__plugins or []
+
+  @plugins.setter
+  def plugins(self, v: list):
+    self.__plugins = v
+
   @property
   def ui_port(self):
     return self.__ui_port
@@ -41,7 +52,11 @@ class AppConfig(Config):
 
     self.name = config.get(APP_NAME_ENV)
     self.ui_port = config.get(APP_UI_PORT_ENV)
-    
+
+    if config.get(APP_PLUGINS_ENV):
+      plugins: str = config.get(APP_PLUGINS_ENV)
+      self.plugins = plugins.split(APP_PLUGINS_DELMITTER)
+
   def write(self):
     config = {}
 
@@ -51,7 +66,10 @@ class AppConfig(Config):
     if self.name:
       config[APP_NAME_ENV] = self.name
 
+    if self.plugins:
+      config[APP_PLUGINS_ENV] = APP_PLUGINS_DELMITTER.join(self.plugins)
+
     if self.ui_port:
       config[APP_UI_PORT_ENV] = self.ui_port
 
-    super().write(config)
+    super().write(config)

stoobly_agent/app/cli/scaffold/app_create_command.py

@@ -1,10 +1,16 @@
 import os
 import pdb
+import shutil
+import yaml
 
+from mergedeep import merge
 from typing import TypedDict
 
 from .app import App
 from .app_command import AppCommand
+from .constants import PLUGIN_CYPRESS, PLUGIN_PLAYWRIGHT, PLUGINS_FOLDER, WORKFLOW_TEST_TYPE
+from .docker.constants import DOCKER_COMPOSE_WORKFLOW_TEMPLATE, PLUGIN_CONTAINER_SERVICE_TEMPLATE, PLUGIN_DOCKER_ENTRYPOINT, PLUGIN_DOCKERFILE_TEMPLATE
+from .templates.constants import CORE_ENTRYPOINT_SERVICE_NAME, CORE_GATEWAY_SERVICE_NAME
 
 class AppCreateOptions(TypedDict):
   docker_socket_path: str
@@ -22,6 +28,9 @@ class AppCreateCommand(AppCommand):
         if kwargs.get('docker_socket_path'):
             self.app_config.docker_socket_path = kwargs['docker_socket_path']
 
+        if kwargs.get('plugin'):
+            self.app_config.plugins = kwargs['plugin']
+
         if kwargs.get('ui_port'):
             self.app_config.ui_port = kwargs['ui_port']
 
@@ -34,6 +43,9 @@ class AppCreateCommand(AppCommand):
         return self.app_config.name
 
     @property
+    def app_plugins(self):
+        return self.app_config.plugins
+
     def app_ui_port(self):
         return self.app_config.ui_port
 
@@ -43,6 +55,101 @@ class AppCreateCommand(AppCommand):
         self.app.copy_folders_and_hidden_files(self.app_templates_root_dir, dest)
 
         with open(os.path.join(dest, '.gitignore'), 'w') as fp:
-            fp.write("\n".join(['gateway/.docker-compose.base.yml', '**/.env']))
+            fp.write("\n".join(
+                [os.path.join(CORE_GATEWAY_SERVICE_NAME, '.docker-compose.base.yml'), '**/.env']
+            ))
+
+        self.app_config.write()
+
+        # Provide plugins
+        warnings = []
+        if PLUGIN_CYPRESS in self.app_plugins:
+            self.__plugin_cypress(dest, PLUGIN_CYPRESS)
+
+            if not self.__cypress_initialized(self.app):
+                warnings.append(f"missing cypress.config.(js|ts), please run `npx cypress open` in {self.app.context_dir_path}")
+
+
+        if PLUGIN_PLAYWRIGHT in self.app_plugins:
+            self.__plugin_playwright(dest, PLUGIN_PLAYWRIGHT)
+
+            if not self.__playwright_initialized(self.app):
+                warnings.append(f"missing playwright.config.(js|ts), please run `npm init playwright@latest` in {self.app.context_dir_path}")
+
+        return {
+            'warnings': warnings
+        }
+
+    def __cypress_initialized(self, app: App):
+        if os.path.exists(os.path.join(app.context_dir_path, 'cypress.config.js')):
+            return True
+            
+        if os.path.exists(os.path.join(app.context_dir_path, 'cypress.config.ts')):
+            return True
+
+        return False
+
+    def __merge_compose_plugin(self, dest_path: str, template_path: str, plugin: str):
+        if not os.path.exists(dest_path):
+            open(dest_path, 'a').close()
+
+        def load_yaml(path):
+            with open(path, 'r') as f:
+                return yaml.safe_load(f) or {}
+
+        data1 = load_yaml(dest_path)
+        data2 = load_yaml(template_path)
+
+        services = data1.get('services') or {}
+        if services.get(PLUGIN_CONTAINER_SERVICE_TEMPLATE.format(plugin=plugin, service=CORE_ENTRYPOINT_SERVICE_NAME)):
+            return
+
+        with open(dest_path, 'w') as out:
+            merged = merge(data1, data2)
+            yaml.dump(merged, out, default_flow_style=False)
+
+    def __playwright_initialized(self, app: App):
+        if os.path.exists(os.path.join(app.context_dir_path, 'playwright.config.js')):
+            return True
+            
+        if os.path.exists(os.path.join(app.context_dir_path, 'playwright.config.ts')):
+            return True
+
+        return False
+
+    def __plugin_cypress(self, dest: str, plugin: str):
+        dockerfile_name = PLUGIN_DOCKERFILE_TEMPLATE.format(plugin=plugin)
+        dockerfile_dest_path = os.path.join(dest, CORE_ENTRYPOINT_SERVICE_NAME, WORKFLOW_TEST_TYPE, dockerfile_name)
+
+        # Copy Dockerfile to workflow
+        dockerfile_src_path = os.path.join(self.templates_root_dir, PLUGINS_FOLDER, plugin, WORKFLOW_TEST_TYPE, dockerfile_name)
+        shutil.copyfile(dockerfile_src_path, dockerfile_dest_path)
+
+        # Merge template into dest compose yml
+        compose_dest_path = os.path.join(
+            dest, CORE_ENTRYPOINT_SERVICE_NAME, WORKFLOW_TEST_TYPE, DOCKER_COMPOSE_WORKFLOW_TEMPLATE.format(workflow=WORKFLOW_TEST_TYPE)
+        )
+        template_path = os.path.join(
+            self.templates_root_dir, PLUGINS_FOLDER, plugin, WORKFLOW_TEST_TYPE, DOCKER_COMPOSE_WORKFLOW_TEMPLATE.format(workflow=WORKFLOW_TEST_TYPE)
+        )
+        self.__merge_compose_plugin(compose_dest_path, template_path, plugin)
+
+    def __plugin_playwright(self, dest: str, plugin: str):
+        # Copy Dockerfile to workflow
+        dockerfile_name = PLUGIN_DOCKERFILE_TEMPLATE.format(plugin=plugin)
+        dockerfile_src_path = os.path.join(self.templates_root_dir, PLUGINS_FOLDER, plugin, WORKFLOW_TEST_TYPE, dockerfile_name)
+        dockerfile_dest_path = os.path.join(dest, CORE_ENTRYPOINT_SERVICE_NAME, WORKFLOW_TEST_TYPE, dockerfile_name)
+        shutil.copyfile(dockerfile_src_path, dockerfile_dest_path)
+
+        entrypoint_src_path = os.path.join(self.templates_root_dir, PLUGINS_FOLDER, plugin, WORKFLOW_TEST_TYPE, PLUGIN_DOCKER_ENTRYPOINT)
+        entrypoint_dest_path = os.path.join(dest, CORE_ENTRYPOINT_SERVICE_NAME, WORKFLOW_TEST_TYPE, PLUGIN_DOCKER_ENTRYPOINT)
+        shutil.copyfile(entrypoint_src_path, entrypoint_dest_path)
 
-        self.app_config.write()
+        # Merge template into dest compose yml
+        compose_dest_path = os.path.join(
+            dest, CORE_ENTRYPOINT_SERVICE_NAME, WORKFLOW_TEST_TYPE, DOCKER_COMPOSE_WORKFLOW_TEMPLATE.format(workflow=WORKFLOW_TEST_TYPE)
+        )
+        template_path = os.path.join(
+            self.templates_root_dir, PLUGINS_FOLDER, plugin, WORKFLOW_TEST_TYPE, DOCKER_COMPOSE_WORKFLOW_TEMPLATE.format(workflow=WORKFLOW_TEST_TYPE)
+        )
+        self.__merge_compose_plugin(compose_dest_path, template_path, plugin)

stoobly_agent/app/cli/scaffold/constants.py

@@ -9,6 +9,8 @@ APP_DIR_ENV = 'APP_DIR'
 APP_DOCKER_SOCKET_PATH_ENV = 'APP_DOCKER_SOCKET_PATH'
 APP_NETWORK_ENV = 'APP_NETWORK'
 APP_NAME_ENV = 'APP_NAME'
+APP_PLUGINS_ENV = 'APP_PLUGINS'
+APP_PLUGINS_DELMITTER = ','
 APP_UI_PORT_ENV = 'APP_UI_PORT'
 BIN_FOLDER_NAME = 'bin'
 CA_CERTS_DIR_ENV = 'CA_CERTS_DIR'
@@ -20,6 +22,9 @@ DOCKER_NAMESPACE = 'docker'
 DOTENV_FILE = '.env'
 DOTENV_PATH_ENV = 'STOOBLY_DOTENV_PATH'
 NAMESERVERS_FILE = '.nameservers'
+PLUGIN_CYPRESS = 'cypress'
+PLUGIN_PLAYWRIGHT = 'playwright'
+PLUGINS_FOLDER = 'plugins'
 PUBLIC_FOLDER_NAME = 'public'
 SERVICE_DETACHED = '${SERVICE_DETACHED}'
 SERVICE_DETACHED_ENV = 'SERVICE_DETACHED'
@@ -29,6 +34,7 @@ SERVICE_HOSTNAME = '${SERVICE_HOSTNAME}'
 SERVICE_HOSTNAME_ENV = 'SERVICE_HOSTNAME'
 SERVICE_ID = '${SERVICE_ID}'
 SERVICE_ID_ENV = 'SERVICE_ID'
+SERVICE_LOCAL_ENV = 'SERVICE_LOCAL'
 SERVICE_NAME = '${SERVICE_NAME}'
 SERVICE_NAME_ENV = 'SERVICE_NAME'
 SERVICE_PROXY_MODE = '${SERVICE_PROXY_MODE}'
@@ -41,10 +47,17 @@ SERVICE_PRIORITY_ENV = 'SERVICE_PRIORITY'
 SERVICE_SCRIPTS = '${SERVICE_SCRIPTS}'
 SERVICE_SCRIPTS_DIR = '/usr/local/bin/services'
 SERVICE_SCRIPTS_ENV = 'SERVICE_SCRIPTS'
+SERVICE_UPSTREAM_HOSTNAME = '${SERVICE_UPSTREAM_HOSTNAME}'
+SERVICE_UPSTREAM_HOSTNAME_ENV = 'SERVICE_UPSTREAM_HOSTNAME'
+SERVICE_UPSTREAM_PORT = '${SERVICE_UPSTREAM_PORT}'
+SERVICE_UPSTREAM_PORT_ENV = 'SERVICE_UPSTREAM_PORT'
+SERVICE_UPSTREAM_SCHEME = '${SERVICE_UPSTREAM_SCHEME}'
+SERVICE_UPSTREAM_SCHEME_ENV = 'SERVICE_UPSTREAM_SCHEME'
 STOOBLY_HOME_DIR = '/home/stoobly'
 STOOBLY_DATA_DIR = os.path.join(STOOBLY_HOME_DIR, DATA_DIR_NAME)
 STOOBLY_CERTS_DIR = os.path.join(STOOBLY_DATA_DIR, CERTS_DIR_NAME)
 USER_ID_ENV = 'USER_ID'
+WORKFLOW_CONTAINER_BRIDGE = 'bridge'
 WORKFLOW_CONTAINER_CONFIGURE = 'configure'
 WORKFLOW_CONTAINER_INIT = 'init'
 WORKFLOW_CONTAINER_PROXY = 'proxy'

stoobly_agent/app/cli/scaffold/docker/constants.py

@@ -8,11 +8,9 @@ DOCKER_COMPOSE_BASE = '.docker-compose.base.yml'
 DOCKER_COMPOSE_BASE_TEMPLATE = '.docker-compose.base.template.yml'
 DOCKER_COMPOSE_CUSTOM = 'docker-compose.yml'
 DOCKER_COMPOSE_NETWORKS = '.docker-compose.networks.yml'
+DOCKER_COMPOSE_WORKFLOW_TEMPLATE = '.docker-compose.{workflow}.yml'
 DOCKERFILE_CONTEXT = '.Dockerfile.context'
 DOCKERFILE_SERVICE = 'Dockerfile.source'
-
-# TODO: add scaffold container name templates here
-
-# Example:
-# COMPOSE_TEMPLATE = 'docker-compose.{workflow}.yml'
-
+PLUGIN_CONTAINER_SERVICE_TEMPLATE = '{service}.{plugin}'
+PLUGIN_DOCKER_ENTRYPOINT = '.entrypoint.sh'
+PLUGIN_DOCKERFILE_TEMPLATE = '.Dockerfile.{plugin}'

stoobly_agent/app/cli/scaffold/docker/service/builder.py

@@ -33,6 +33,7 @@ class ServiceBuilder(Builder):
     self.app_builder = app_builder
 
     self.__config = config
+    self.__upstream_port = None
     self.__env = [SERVICE_NAME_ENV, WORKFLOW_NAME_ENV]
     self.__service_name = os.path.basename(service_path)
     self.__working_dir = os.path.join(
@@ -55,6 +56,10 @@ class ServiceBuilder(Builder):
   def configure_base_service(self):
     return self.services.get(self.configure_base)
 
+  @property
+  def upstream_port(self) -> int:
+    return self.__upstream_port
+
   @property
   def extends_service(self):
     if self.config.detached:
@@ -99,9 +104,6 @@ class ServiceBuilder(Builder):
     environment = { **self.env_dict() }
     labels = [
       'traefik.enable=true',
-      f"traefik.http.routers.{service_id}.rule=Host(`{SERVICE_HOSTNAME}`)",
-      f"traefik.http.routers.{service_id}.entrypoints={SERVICE_PORT}",
-      f"traefik.http.services.{service_id}.loadbalancer.server.port={SERVICE_PORT}"
     ]
     volumes = []
 
@@ -109,7 +111,14 @@ class ServiceBuilder(Builder):
       self.__with_detached_volumes(volumes)
 
     if self.config.tls:
-      labels.append(f"traefik.http.routers.{service_id}.tls=true")
+      labels.append(f"traefik.tcp.routers.{service_id}.entrypoints={SERVICE_PORT}")
+      labels.append(f"traefik.tcp.routers.{service_id}.rule=HostSNI(`{SERVICE_HOSTNAME}`)")
+      labels.append(f"traefik.tcp.routers.{service_id}.tls.passthrough=true")
+      labels.append(f"traefik.tcp.services.{service_id}.loadbalancer.server.port={SERVICE_PORT}")
+    else:
+      labels.append(f"traefik.http.routers.{service_id}.entrypoints={SERVICE_PORT}")
+      labels.append(f"traefik.http.routers.{service_id}.rule=Host(`{SERVICE_HOSTNAME}`)")
+      labels.append(f"traefik.http.services.{service_id}.loadbalancer.server.port={SERVICE_PORT}")
 
     base = {
       'environment': environment,
@@ -178,6 +187,12 @@ class ServiceBuilder(Builder):
       env[e] = '${' + e + '}'
     return env
 
+  def with_upstream_port(self, v: int):
+    if not isinstance(v, int):
+      return self
+    self.__upstream_port = v
+    return self
+
   def with_env(self, v: List[str]): 
     if not isinstance(v, list):
       return self

stoobly_agent/app/cli/scaffold/docker/workflow/builder.py

@@ -94,7 +94,6 @@ class WorkflowBuilder(Builder):
     if not self.service_builder.init_base_service:
       return
 
-      return
     service = {
       'extends': self.service_builder.build_extends_init_base(self.dir_path),
       'profiles': self.profiles,
@@ -138,10 +137,6 @@ class WorkflowBuilder(Builder):
     }
 
     if self.configure in self.services:
-      depends_on[self.init] = {
-        'condition': 'service_completed_successfully',
-      }
-
       depends_on[self.configure] = {
         'condition': 'service_completed_successfully',
       }
@@ -158,19 +153,6 @@ class WorkflowBuilder(Builder):
       env[e] = '${' + e + '}'
     return env
 
-  def initialize_custom_file(self):
-    dest = self.custom_compose_file_path
-
-    if not os.path.exists(dest):
-      compose = {
-        'services': {}
-      }
-
-      if self.networks:
-        compose['networks'] = self.networks
-
-      super().write(compose, dest)
-
   def write(self):
     compose = {
       'services': self.services,

stoobly_agent/app/cli/scaffold/docker/workflow/command_decorator.py

@@ -0,0 +1,24 @@
+from ...constants import (
+  SERVICE_PROXY_MODE, SERVICE_UPSTREAM_HOSTNAME, SERVICE_UPSTREAM_PORT, SERVICE_UPSTREAM_SCHEME,
+)
+from .builder import WorkflowBuilder
+
+class CommandDecorator():
+
+  def __init__(self, workflow_builder: WorkflowBuilder):
+    self.__workflow_builder = workflow_builder
+
+  @property
+  def workflow_builder(self):
+    return self.__workflow_builder
+
+  @property
+  def proxy_mode(self):
+    config = self.workflow_builder.config
+    if config.upstream_hostname == 'host.docker.internal':
+      return f"upstream:{SERVICE_UPSTREAM_SCHEME}://{SERVICE_UPSTREAM_HOSTNAME}:{SERVICE_UPSTREAM_PORT}"
+
+    if config.hostname != config.upstream_hostname or config.scheme != config.upstream_scheme or config.port != config.upstream_port:
+      return f"reverse:{SERVICE_UPSTREAM_SCHEME}://{SERVICE_UPSTREAM_HOSTNAME}:{SERVICE_UPSTREAM_PORT}"
+
+    return 'regular'

stoobly_agent/app/cli/scaffold/docker/workflow/decorators_factory.py

@@ -1,7 +1,9 @@
 from stoobly_agent.app.cli.scaffold.service_config import ServiceConfig
 
 from ...constants import WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
+from .detached_decorator import DetachedDecorator
 from .dns_decorator import DnsDecorator
+from .local_decorator import LocalDecorator
 from .mock_decorator import MockDecorator
 from .reverse_proxy_decorator import ReverseProxyDecorator
 
@@ -12,12 +14,15 @@ def get_workflow_decorators(workflow: str, service_config: ServiceConfig):
     if service_config.hostname:
       workflow_decorators.append(ReverseProxyDecorator)
       workflow_decorators.append(DnsDecorator)
+
+      if service_config.local:
+        workflow_decorators.append(LocalDecorator)
   elif workflow == WORKFLOW_MOCK_TYPE or workflow == WORKFLOW_TEST_TYPE:
      if service_config.hostname:
-      workflow_decorators.append(ReverseProxyDecorator if service_config.detached else MockDecorator)    
+      workflow_decorators.append(DetachedDecorator if service_config.detached else MockDecorator)
       workflow_decorators.append(DnsDecorator)
   else:
     if service_config.hostname:
-      workflow_decorators.append(ReverseProxyDecorator if service_config.detached else MockDecorator) 
+      workflow_decorators.append(DetachedDecorator if service_config.detached else MockDecorator) 
 
   return workflow_decorators

stoobly_agent/app/cli/scaffold/docker/workflow/detached_decorator.py

@@ -0,0 +1,42 @@
+import os
+import pdb
+
+from ...constants import SERVICE_HOSTNAME, SERVICE_PORT, STOOBLY_CERTS_DIR
+from .builder import WorkflowBuilder
+from .command_decorator import CommandDecorator
+
+class DetachedDecorator(CommandDecorator):
+
+  def __init__(self, workflow_builder: WorkflowBuilder):
+    super().__init__(workflow_builder)
+
+  @property
+  def service_builder(self):
+    return self.workflow_builder.service_builder
+
+  def decorate(self):
+    config = self.service_builder.config
+
+    command = [
+      '--headless',
+      '--lifecycle-hooks-path', 'lifecycle_hooks.py',
+      '--proxy-mode', self.proxy_mode,
+      '--proxy-port', f"{SERVICE_PORT}",
+      '--public-directory-path', 'public',
+      '--response-fixtures-path', 'fixtures.yml',
+      '--ssl-insecure'
+    ]
+
+    if config.scheme == 'https':
+      command.append('--certs')
+      command.append(os.path.join(STOOBLY_CERTS_DIR, f"{SERVICE_HOSTNAME}-joined.pem"))
+
+    services = self.workflow_builder.services
+    proxy_name = self.workflow_builder.proxy
+    proxy_service = services.get(proxy_name) or {}
+
+    services[proxy_name] = { 
+      **proxy_service,
+      **{ 'command': command },
+    }
+