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

stoobly_agent/__init__.py

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

stoobly_agent/__main__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""
+Entry point for stoobly_agent when run as a module.
+"""
+
+from .cli import main
+
+if __name__ == '__main__':
+    main()
+

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/cli/ca_cert_cli.py

@@ -48,14 +48,18 @@ def mkcert(**kwargs):
 )
 def install(**kwargs):
     ca_certs_dir_path = kwargs['ca_certs_dir_path']
+
+    ca_cert_install(ca_certs_dir_path)
+
+@ca_cert.command()
+def uninstall():
+    print("Not yet implemented. Stay tuned!")
+
+def ca_cert_install(ca_certs_dir_path: str):
     installer = CertificateAuthority(ca_certs_dir_path)
 
     try:
         installer.install()
     except Exception as e:
         print(e, file=sys.stderr)
-        sys.exit(1)
-
-@ca_cert.command()
-def uninstall():
-    print("Not yet implemented. Stay tuned!")
+        sys.exit(1)

stoobly_agent/app/cli/helpers/replay_facade.py

@@ -17,9 +17,9 @@ class ReplayCliOptions(TypedDict):
   lifecycle_hooks_path: str
   on_response: Callable
   project_key: str
-  public_directory_path: str
+  public_directory_path: str  # Comma-separated list of paths, optionally with origin prefix
   record: bool
-  response_fixtures_path: str
+  response_fixtures_path: str  # Comma-separated list of paths, optionally with origin prefix
   scenario_key: str
   scheme: str
   trace: Trace

stoobly_agent/app/cli/intercept_cli.py

@@ -10,7 +10,7 @@ from .helpers.handle_config_update_service import handle_intercept_active_update
 
 settings: Settings = Settings.instance()
 
-mode_options = [mode.MOCK, mode.RECORD, mode.REPLAY, mode.TEST]
+mode_options = [mode.MOCK, mode.RECORD, mode.REPLAY]
 
 if settings.cli.features.remote:
     mode_options.append(mode.TEST)
@@ -87,9 +87,9 @@ def disable(**kwargs):
     help="Configure intercept"
 )
 @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))
+@click.option('--order', help=f"Order to use for recording. Valid options: {order_options}")
+@click.option('--policy', help=f"Policy to use for recording. Valid options: {policy_options}")
+@click.option('--strategy', help=f"Strategy to use for recording. Valid options: {strategy_options}")
 def configure(**kwargs):
     settings: Settings = Settings.instance()
 
@@ -172,7 +172,7 @@ def configure(**kwargs):
     help="Show intercept"
 )
 def show(**kwargs):
-    settings = Settings.instance()
+    settings: Settings = Settings.instance()
 
     _mode = settings.proxy.intercept.mode
     project_key = ProjectKey(settings.proxy.intercept.project_key)

stoobly_agent/app/cli/request_cli.py

@@ -134,10 +134,10 @@ if is_local:
     Configure which tests to print. Defaults to {test_output_level.PASSED}.
   '''
 )
-@click.option('--public-directory-path', help='Path to public files. Used for mocking requests.')
+@click.option('--public-directory-path', multiple=True, help='Path to public files. Used for mocking requests. Can take the form <FOLDER-PATH>[:<ORIGIN>].')
 @ConditionalDecorator(lambda f: click.option('--remote-project-key', help='Use remote project for endpoint definitions.')(f), is_remote and is_local)
 @ConditionalDecorator(lambda f: click.option('--report-key', help='Save to report.')(f), is_remote)
-@click.option('--response-fixtures-path', help='Path to response fixtures yaml. Used for mocking requests.')
+@click.option('--response-fixtures-path', multiple=True, help='Path to response fixtures yaml. Used for mocking requests. Can take the form <FILE-PATH>[:<ORIGIN>].')
 @ConditionalDecorator(lambda f: click.option('--save', is_flag=True, default=False, help='Saves test results.')(f), is_remote)
 @click.option('--scheme', type=click.Choice(['http', 'https']), help='Rewrite request scheme.')
 @click.option('--strategy', default=test_strategy.DIFF, type=click.Choice([test_strategy.CONTRACT, test_strategy.CUSTOM, test_strategy.DIFF, test_strategy.FUZZY]), help='How to test responses.')

stoobly_agent/app/cli/scaffold/app.py

@@ -1,5 +1,6 @@
 import hashlib
 import os
+import re
 import shutil
 
 from stoobly_agent.config.data_dir import DataDir, DATA_DIR_NAME
@@ -62,10 +63,6 @@ class App():
   def scaffold_namespace(self):
     return self.__scaffold_namespace
 
-  @property
-  def scaffold_namespace_path(self):
-    return os.path.join(self.data_dir_path, self.scaffold_namespace)
-
   @property
   def dir_path(self):
     return self.__dir_path
@@ -101,7 +98,7 @@ class App():
 
     return services
 
-  def copy_folders_and_hidden_files(self, src, dst):
+  def copy_folders_and_hidden_files(self, src: str, dst: str, ignore: list = []):
       os.makedirs(dst, exist_ok=True)
 
       # Walk through the source directory
@@ -109,6 +106,18 @@ class App():
           # Copy hidden files only
           for file_name in files:
               src_file_path = os.path.join(root, file_name)
+
+              ignored = False
+
+              # Skip files that match the ignore list pattern, use regex
+              for ignore_pattern in ignore:
+                  if re.match(os.path.join(src, ignore_pattern), src_file_path):
+                      ignored = True
+                      break
+
+              if ignored:
+                continue
+
               dst_file_path = os.path.join(dst, os.path.relpath(root, src), file_name)
 
               if not file_name.startswith('.'):

stoobly_agent/app/cli/scaffold/app_command.py

@@ -44,10 +44,6 @@ class AppCommand(Command):
       DOCKER_COMPOSE_NETWORKS
     )
 
-  @property
-  def scaffold_namespace_path(self):
-    return self.app.scaffold_namespace_path
-
   @property
   def app_templates_root_dir(self):
     return os.path.join(self.templates_root_dir, 'app')

stoobly_agent/app/cli/scaffold/app_config.py

@@ -1,7 +1,9 @@
 import os
 
 from .config import Config
-from .constants import APP_DOCKER_SOCKET_PATH_ENV, APP_NAME_ENV, APP_NETWORK_ENV, APP_PLUGINS_DELMITTER, APP_PLUGINS_ENV, APP_UI_PORT_ENV
+from .constants import (
+  APP_DOCKER_SOCKET_PATH_ENV, APP_NAME_ENV, APP_PLUGINS_DELMITTER, APP_PLUGINS_ENV, APP_PROXY_PORT_ENV, APP_RUN_ON_ENV, APP_RUN_ON_DELIMITER, APP_UI_PORT_ENV, APP_VERSION_ENV, RUN_ON_DOCKER, RUN_ON_LOCAL
+)
 
 class AppConfig(Config):
 
@@ -11,6 +13,8 @@ class AppConfig(Config):
     self.__docker_socket_path = '/var/run/docker.sock'
     self.__name = None
     self.__plugins = None
+    self.__proxy_port = None
+    self.__run_on = None
     self.__ui_port = None
 
     self.load()
@@ -39,24 +43,58 @@ class AppConfig(Config):
   def plugins(self, v: list):
     self.__plugins = v
 
+  @property
+  def run_on(self):
+    return self.__run_on or [RUN_ON_DOCKER]
+
+  @run_on.setter
+  def run_on(self, v: list):
+    self.__run_on = v
+
+  @property
+  def run_on_local(self):
+    return RUN_ON_LOCAL in self.run_on
+
+  @property
+  def proxy_port(self):
+    return self.__proxy_port or 8080
+
+  @proxy_port.setter
+  def proxy_port(self, v):
+    self.__proxy_port = v
+
   @property
   def ui_port(self):
-    return self.__ui_port
+    return self.__ui_port or 4200
 
   @ui_port.setter
   def ui_port(self, v):
     self.__ui_port = v
 
+  @property
+  def version(self):
+    return self.__version or None
+
+  @version.setter
+  def version(self, v):
+    self.__version = v
+
   def load(self, config = None):
     config = config or self.read()
 
     self.name = config.get(APP_NAME_ENV)
+    self.proxy_port = config.get(APP_PROXY_PORT_ENV)
     self.ui_port = config.get(APP_UI_PORT_ENV)
+    self.version = config.get(APP_VERSION_ENV)
 
     if config.get(APP_PLUGINS_ENV):
       plugins: str = config.get(APP_PLUGINS_ENV)
       self.plugins = plugins.split(APP_PLUGINS_DELMITTER)
 
+    if config.get(APP_RUN_ON_ENV):
+      run_on: str = config.get(APP_RUN_ON_ENV)
+      self.run_on = run_on.split(APP_RUN_ON_DELIMITER)
+
   def write(self):
     config = {}
 
@@ -69,7 +107,16 @@ class AppConfig(Config):
     if self.plugins:
       config[APP_PLUGINS_ENV] = APP_PLUGINS_DELMITTER.join(self.plugins)
 
+    if self.run_on:
+      config[APP_RUN_ON_ENV] = APP_RUN_ON_DELIMITER.join(self.run_on)
+
+    if self.proxy_port:
+      config[APP_PROXY_PORT_ENV] = self.proxy_port
+
     if self.ui_port:
       config[APP_UI_PORT_ENV] = self.ui_port
+    
+    if self.version:
+      config[APP_VERSION_ENV] = self.version
 
     super().write(config)

stoobly_agent/app/cli/scaffold/app_create_command.py

@@ -1,20 +1,25 @@
+from math import e
 import os
 import pdb
-import shutil
-import yaml
 
-from mergedeep import merge
+import shutil
 from typing import TypedDict
 
+from stoobly_agent import VERSION
+from stoobly_agent.app.cli.scaffold.docker.constants import DOCKER_COMPOSE_WORKFLOW
+
 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
+from .constants import PLUGIN_CYPRESS, PLUGIN_PLAYWRIGHT, RUN_ON_DOCKER, RUN_ON_LOCAL
+from .docker.template_files import plugin_docker_cypress, plugin_docker_playwright, plugin_local_cypress, plugin_local_playwright, remove_app_docker_files, remove_service_docker_files
+from .templates.constants import CORE_GATEWAY_SERVICE_NAME, CORE_MOCK_UI_SERVICE_NAME, MAINTAINED_RUN
 
 class AppCreateOptions(TypedDict):
   docker_socket_path: str
   name: str
+  plugin: list
+  proxy_port: int
+  run_on: list
   ui_port: int
 
 class AppCreateCommand(AppCommand):
@@ -31,6 +36,12 @@ class AppCreateCommand(AppCommand):
         if kwargs.get('plugin'):
             self.app_config.plugins = kwargs['plugin']
 
+        if kwargs.get('proxy_port'):
+            self.app_config.proxy_port = kwargs['proxy_port']
+
+        if kwargs.get('run_on'):
+            self.app_config.run_on = kwargs['run_on']
+
         if kwargs.get('ui_port'):
             self.app_config.ui_port = kwargs['ui_port']
 
@@ -46,40 +57,154 @@ class AppCreateCommand(AppCommand):
     def app_plugins(self):
         return self.app_config.plugins
 
+    @property
+    def app_run_on(self):
+        return self.app_config.run_on
+
+    @property
+    def app_proxy_port(self):
+        return self.app_config.proxy_port
+
+    @property
     def app_ui_port(self):
         return self.app_config.ui_port
 
+    @property
+    def app_version(self):
+        return self.app_config.version
+
     def build(self):
+        self.__migrate()
+
         dest = self.scaffold_namespace_path
+        ignore = []
+        warnings = []
 
-        self.app.copy_folders_and_hidden_files(self.app_templates_root_dir, dest)
+        if RUN_ON_LOCAL in self.app_run_on:
+            ignore.append(f"{CORE_GATEWAY_SERVICE_NAME}/.*")
+            ignore.append(f"{CORE_MOCK_UI_SERVICE_NAME}/.*")
 
-        with open(os.path.join(dest, '.gitignore'), 'w') as fp:
-            fp.write("\n".join(
-                [os.path.join(CORE_GATEWAY_SERVICE_NAME, '.docker-compose.base.yml'), '**/.env']
-            ))
+        if RUN_ON_DOCKER in self.app_run_on:
+            ignore.append(f".*/{MAINTAINED_RUN}")
 
-        self.app_config.write()
+        # Copy all app templates
+        self.app.copy_folders_and_hidden_files(self.app_templates_root_dir, dest, ignore)
 
-        # Provide plugins
-        warnings = []
-        if PLUGIN_CYPRESS in self.app_plugins:
-            self.__plugin_cypress(dest, PLUGIN_CYPRESS)
+        # Remove Docker-specific files if not using Docker
+        if RUN_ON_DOCKER not in self.app_run_on:
+            remove_app_docker_files(dest)
+            remove_service_docker_files(dest)
 
+        if PLUGIN_CYPRESS in self.app_plugins:
             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}")
 
+        if RUN_ON_DOCKER in self.app_run_on:
+            with open(os.path.join(dest, '.gitignore'), 'w') as fp:
+                fp.write("\n".join(
+                    [os.path.join(CORE_GATEWAY_SERVICE_NAME, '.docker-compose.base.yml'), '**/.env']
+                ))
+
+            # Provide plugins
+            if PLUGIN_CYPRESS in self.app_plugins:
+                plugin_docker_cypress(self.templates_root_dir, PLUGIN_CYPRESS, dest)
+
+            if PLUGIN_PLAYWRIGHT in self.app_plugins:
+                plugin_docker_playwright(self.templates_root_dir, PLUGIN_PLAYWRIGHT, dest)
+        else:
+            if PLUGIN_CYPRESS in self.app_plugins:
+                plugin_local_cypress(self.templates_root_dir, PLUGIN_CYPRESS, dest)
+
+            if PLUGIN_PLAYWRIGHT in self.app_plugins:
+                plugin_local_playwright(self.templates_root_dir, PLUGIN_PLAYWRIGHT, dest)
+
+            with open(os.path.join(dest, '.gitignore'), 'w') as fp:
+                fp.write("\n".join(
+                    ['**/.env']
+                ))
+
+        self.app_config.write()
+
         return {
             'warnings': warnings
         }
 
+    def __compare_versions(self, version1, version2):
+        """
+        Compare two semantic versions.
+        
+        Args:
+            version1: First version string (e.g., '1.10.1')
+            version2: Second version string (e.g., '1.9.0')
+            
+        Returns:
+            -1 if version1 < version2
+            0 if version1 == version2
+            1 if version1 > version2
+        """
+        try:
+            v1_parts = [int(x) for x in version1.split('.')]
+            v2_parts = [int(x) for x in version2.split('.')]
+            
+            # Pad shorter version with zeros
+            max_len = max(len(v1_parts), len(v2_parts))
+            v1_parts.extend([0] * (max_len - len(v1_parts)))
+            v2_parts.extend([0] * (max_len - len(v2_parts)))
+            
+            for v1_part, v2_part in zip(v1_parts, v2_parts):
+                if v1_part < v2_part:
+                    return -1
+                elif v1_part > v2_part:
+                    return 1
+            
+            return 0
+        except (ValueError, AttributeError):
+            # If version parsing fails, treat as invalid and return -1 (version1 < version2)
+            return -1
+
+    def __migrate(self):
+        if not self.app_version or self.__compare_versions(self.app_version, '1.10.0') < 0:
+            new_scaffold_namespace_path = self.scaffold_namespace_path
+            if not os.path.exists(new_scaffold_namespace_path):
+                old_scaffold_namespace_path = os.path.join(self.data_dir_path, 'docker')
+                if os.path.exists(old_scaffold_namespace_path):
+                    shutil.move(old_scaffold_namespace_path, new_scaffold_namespace_path)
+                else:
+                    os.makedirs(new_scaffold_namespace_path)
+
+            # For each file in self.scaffold_namespace_path/<SERVICE-NAME>/<WORKFLOW-NAME>/bin 
+            # move it to self.scaffold_namespace_path/<SERVICE-NAME>/<WORKFLOW-NAME>
+            for service_name in os.listdir(new_scaffold_namespace_path):
+                service_path = os.path.join(new_scaffold_namespace_path, service_name)
+                if not os.path.isdir(service_path):
+                    continue
+
+                for workflow_name in os.listdir(service_path):
+                    workflow_path = os.path.join(new_scaffold_namespace_path, service_name, workflow_name)
+                    if not os.path.isdir(workflow_path):
+                        continue
+                    
+                    docker_compose_workflow_path = os.path.join(workflow_path, f".docker-compose.{workflow_name}.yml")
+                    if os.path.exists(docker_compose_workflow_path):
+                        os.rename(docker_compose_workflow_path, os.path.join(workflow_path, DOCKER_COMPOSE_WORKFLOW))
+
+                    bin_path = os.path.join(workflow_path, 'bin')
+                    if not os.path.isdir(bin_path):
+                        continue
+
+                    for file in os.listdir(bin_path):
+                        shutil.move(os.path.join(bin_path, file), os.path.join(workflow_path, file))
+
+                    # Remove the bin folder
+                    shutil.rmtree(bin_path)
+
+            self.app_config.version = VERSION
+            self.app_config.write()
+
     def __cypress_initialized(self, app: App):
         if os.path.exists(os.path.join(app.context_dir_path, 'cypress.config.js')):
             return True
@@ -89,25 +214,6 @@ class AppCreateCommand(AppCommand):
 
         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
@@ -115,41 +221,4 @@ class AppCreateCommand(AppCommand):
         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)
-
-        # 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)
+        return False

stoobly_agent/app/cli/scaffold/constants.py

@@ -11,21 +11,26 @@ APP_NETWORK_ENV = 'APP_NETWORK'
 APP_NAME_ENV = 'APP_NAME'
 APP_PLUGINS_ENV = 'APP_PLUGINS'
 APP_PLUGINS_DELMITTER = ','
+APP_PROXY_PORT_ENV = 'APP_PROXY_PORT'
+APP_RUN_ON_ENV = 'APP_RUN_ON'
+APP_RUN_ON_DELIMITER = ','
 APP_UI_PORT_ENV = 'APP_UI_PORT'
+APP_VERSION_ENV = 'APP_VERSION'
 BIN_FOLDER_NAME = 'bin'
 CA_CERTS_DIR_ENV = 'CA_CERTS_DIR'
 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'
+FIXTURES_FILE_NAME = 'fixtures.yml'
 NAMESERVERS_FILE = '.nameservers'
 PLUGIN_CYPRESS = 'cypress'
 PLUGIN_PLAYWRIGHT = 'playwright'
 PLUGINS_FOLDER = 'plugins'
 PUBLIC_FOLDER_NAME = 'public'
+RUN_ON_DOCKER = 'docker'
+RUN_ON_LOCAL = 'local'
 SERVICE_DETACHED = '${SERVICE_DETACHED}'
 SERVICE_DETACHED_ENV = 'SERVICE_DETACHED'
 SERVICE_DNS = '${SERVICE_DNS}'
@@ -37,8 +42,6 @@ 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}'
@@ -53,6 +56,7 @@ 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)
@@ -80,3 +84,4 @@ WORKFLOW_TEST_TYPE = 'test'
 
 CORE_WORKFLOWS = [WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]
 WORKFLOW_TEMPLATE_OPTION = Literal[WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE]
+RUN_ON_OPTIONS = [RUN_ON_DOCKER, RUN_ON_LOCAL]

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

@@ -8,7 +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'
+DOCKER_COMPOSE_WORKFLOW = '.docker-compose.yml'
+DOCKER_MAKEFILE = 'Makefile'
+DOCKER_MAKEFILE_DOT = '.Makefile'
 DOCKERFILE_CONTEXT = '.Dockerfile.context'
 DOCKERFILE_SERVICE = 'Dockerfile.source'
 PLUGIN_CONTAINER_SERVICE_TEMPLATE = '{service}.{plugin}'

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

@@ -2,21 +2,21 @@ 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 .builder import DockerServiceBuilder
 from .types import BuildDecoratorOptions
 
 class BuildDecorator():
 
-  def __init__(self, service_builder: ServiceBuilder):
+  def __init__(self, service_builder: DockerServiceBuilder):
     self.__service_builder = service_builder
 
   def decorate(self, **kwargs: BuildDecoratorOptions):
     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: