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

stoobly_agent/__init__.py

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

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/application_http_request_handler.py

@@ -104,11 +104,14 @@ class ApplicationHTTPRequestHandler(SimpleHTTPRequestHandler):
                 headers.CLIENT.title(),
                 custom_headers.DO_PROXY.title(),
                 headers.EXPIRY.title(),
+                custom_headers.REQUEST_ORIGIN.title(),
+                headers.TOKEN_TYPE.title(),
+                headers.UID.title(),
+
+                # ProxyController headers
                 headers.PROXY_HEADERS.title(),
                 headers.REQUEST_PATH.title(),
                 custom_headers.SERVICE_URL.title(),
-                headers.TOKEN_TYPE.title(),
-                headers.UID.title(),
             ])
             self.send_header(header, allowed_headers)
             rendered_headers.append(header)

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'
@@ -16,10 +18,12 @@ CERTS_DIR_ENV = 'CERTS_DIR'
 COMPOSE_TEMPLATE = '.docker-compose.{workflow}.yml'
 CONFIG_FILE = '.config.yml'
 CONTEXT_DIR_ENV = 'CONTEXT_DIR'
-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,10 +33,9 @@ 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}'
-SERVICE_PROXY_MODE_ENV = 'SERVICE_PROXY_MODE'
 SERVICE_SCHEME = '${SERVICE_SCHEME}'
 SERVICE_SCHEME_ENV = 'SERVICE_SCHEME'
 SERVICE_PORT = '${SERVICE_PORT}'
@@ -41,10 +44,18 @@ 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'
+SERVICES_NAMESPACE = 'services'
 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/build_decorator.py

@@ -2,7 +2,7 @@ import pdb
 
 from typing import TypedDict
 
-from ...constants import DOCKER_NAMESPACE
+from ...constants import SERVICES_NAMESPACE
 from ..constants import DOCKERFILE_SERVICE
 from .builder import ServiceBuilder
 from .types import BuildDecoratorOptions
@@ -16,7 +16,7 @@ class BuildDecorator():
     service_builder = self.__service_builder
     build = {
       'context': '../..', # Assumes app root is 2 levels up
-      'dockerfile': f"./{DOCKER_NAMESPACE}/{service_builder.service_name}/{DOCKERFILE_SERVICE}"
+      'dockerfile': f"./{SERVICES_NAMESPACE}/{service_builder.service_name}/{DOCKERFILE_SERVICE}"
     }
 
     if 'build_args' in kwargs:

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

@@ -7,12 +7,13 @@ from stoobly_agent.config.data_dir import DATA_DIR_NAME
 
 from ...app_config import AppConfig
 from ...constants import (
-  APP_DIR, DOCKER_NAMESPACE, 
+  APP_DIR, SERVICES_NAMESPACE, 
   SERVICE_HOSTNAME, SERVICE_HOSTNAME_ENV,
   SERVICE_NAME, SERVICE_NAME_ENV, 
   SERVICE_ID,
   SERVICE_PORT, SERVICE_PORT_ENV, 
-  SERVICE_SCHEME, SERVICE_SCHEME_ENV, 
+  SERVICE_SCHEME, SERVICE_SCHEME_ENV,
+  SERVICE_UPSTREAM_HOSTNAME, SERVICE_UPSTREAM_HOSTNAME_ENV, SERVICE_UPSTREAM_PORT, SERVICE_UPSTREAM_PORT_ENV, SERVICE_UPSTREAM_SCHEME, SERVICE_UPSTREAM_SCHEME_ENV,
   STOOBLY_HOME_DIR, STOOBLY_HOME_DIR, 
   WORKFLOW_NAME, WORKFLOW_NAME_ENV, WORKFLOW_SCRIPTS, WORKFLOW_TEMPLATE
 )
@@ -33,10 +34,11 @@ 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(
-      STOOBLY_HOME_DIR, DATA_DIR_NAME, DOCKER_NAMESPACE, SERVICE_NAME, WORKFLOW_NAME
+      STOOBLY_HOME_DIR, DATA_DIR_NAME, SERVICES_NAMESPACE, SERVICE_NAME, WORKFLOW_NAME
     )
 
   @property
@@ -55,6 +57,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 +105,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 +112,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 +188,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
@@ -205,13 +221,23 @@ class ServiceBuilder(Builder):
     volumes.append(f"{self.service_name}:{STOOBLY_HOME_DIR}/{DATA_DIR_NAME}")
 
     # Mount docker folder
-    volumes.append(f"../:{STOOBLY_HOME_DIR}/{DATA_DIR_NAME}/{DOCKER_NAMESPACE}")
+    volumes.append(f"../:{STOOBLY_HOME_DIR}/{DATA_DIR_NAME}/{SERVICES_NAMESPACE}")
 
   def __with_url_environment(self, environment):
-    environment[SERVICE_HOSTNAME_ENV] = SERVICE_HOSTNAME
+    if self.config.hostname:
+      environment[SERVICE_HOSTNAME_ENV] = SERVICE_HOSTNAME
 
     if self.config.scheme:
       environment[SERVICE_SCHEME_ENV] = SERVICE_SCHEME
 
     if self.config.port:
-      environment[SERVICE_PORT_ENV] = SERVICE_PORT
+      environment[SERVICE_PORT_ENV] = SERVICE_PORT
+
+    if self.config.upstream_hostname:
+      environment[SERVICE_UPSTREAM_HOSTNAME_ENV] = SERVICE_UPSTREAM_HOSTNAME
+
+    if self.config.upstream_port:
+      environment[SERVICE_UPSTREAM_PORT_ENV] = SERVICE_UPSTREAM_PORT
+
+    if self.config.upstream_scheme:
+      environment[SERVICE_UPSTREAM_SCHEME_ENV] = SERVICE_UPSTREAM_SCHEME

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,
@@ -183,12 +165,3 @@ class WorkflowBuilder(Builder):
       compose['volumes'] = self.volumes
 
     super().write(compose)
-
-  def __with_url_environment(self, environment):
-    environment[SERVICE_HOSTNAME_ENV] = SERVICE_HOSTNAME
-
-    if self.config.scheme:
-      environment[SERVICE_SCHEME_ENV] = SERVICE_SCHEME
-
-    if self.config.port:
-      environment[SERVICE_PORT_ENV] = SERVICE_PORT