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

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

@@ -0,0 +1,25 @@
+from ...constants import (
+  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 },
+    }
+

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

@@ -0,0 +1,26 @@
+from .builder import WorkflowBuilder
+
+class LocalDecorator():
+
+  def __init__(self, workflow_builder: WorkflowBuilder):
+    self.__workflow_builder = workflow_builder
+
+  @property
+  def workflow_builder(self):
+    return self.__workflow_builder
+
+  @property
+  def service_builder(self):
+    return self.workflow_builder.service_builder
+
+  def decorate(self):
+    proxy_name = self.workflow_builder.proxy
+    services = self.workflow_builder.services
+
+    if not proxy_name in services:
+      services[proxy_name] = {}
+
+    if 'extra_hosts' not in services[proxy_name]:
+      services[proxy_name]['extra_hosts'] = []
+
+    services[proxy_name]['extra_hosts'].append('host.docker.internal:host-gateway')

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

@@ -1,17 +1,16 @@
 import os
 import pdb
 
-from ...constants import SERVICE_HOSTNAME, SERVICE_PORT, SERVICE_PROXY_MODE, STOOBLY_CERTS_DIR
+from ...constants import (
+  SERVICE_HOSTNAME, SERVICE_PORT, STOOBLY_CERTS_DIR,
+)
 from .builder import WorkflowBuilder
+from .command_decorator import CommandDecorator
 
-class MockDecorator():
+class MockDecorator(CommandDecorator):
 
   def __init__(self, workflow_builder: WorkflowBuilder):
-    self.__workflow_builder = workflow_builder
-
-  @property
-  def workflow_builder(self):
-    return self.__workflow_builder
+    super().__init__(workflow_builder)
 
   @property
   def service_builder(self):
@@ -24,7 +23,7 @@ class MockDecorator():
       '--headless',
       '--intercept',
       '--lifecycle-hooks-path', 'lifecycle_hooks.py',
-      '--proxy-mode', SERVICE_PROXY_MODE,
+      '--proxy-mode', self.proxy_mode,
       '--proxy-port', f"{SERVICE_PORT}",
       '--public-directory-path', 'public',
       '--response-fixtures-path', 'fixtures.yml',
@@ -35,8 +34,8 @@ class MockDecorator():
       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
+    services = self.workflow_builder.services
+    proxy_name = self.workflow_builder.proxy
     proxy_service = services.get(proxy_name) or {}
 
     services[proxy_name] = { 

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

@@ -3,17 +3,14 @@ import pdb
 
 from urllib.parse import urlparse
 
-from ...constants import SERVICE_HOSTNAME, SERVICE_PORT, SERVICE_PROXY_MODE, STOOBLY_CERTS_DIR
+from ...constants import SERVICE_HOSTNAME, SERVICE_PORT, STOOBLY_CERTS_DIR
 from .builder import WorkflowBuilder
+from .command_decorator import CommandDecorator
 
-class ReverseProxyDecorator():
+class ReverseProxyDecorator(CommandDecorator):
 
   def __init__(self, workflow_builder: WorkflowBuilder):
-    self.__workflow_builder = workflow_builder
-
-  @property
-  def workflow_builder(self):
-    return self.__workflow_builder
+    super().__init__(workflow_builder)
 
   @property
   def service_builder(self):
@@ -25,7 +22,7 @@ class ReverseProxyDecorator():
     command = [
       '--headless',
       '--lifecycle-hooks-path', 'lifecycle_hooks.py',
-      '--proxy-mode', SERVICE_PROXY_MODE,
+      '--proxy-mode', self.proxy_mode,
       '--proxy-port', f"{SERVICE_PORT}",
       '--ssl-insecure'
     ]

stoobly_agent/app/cli/scaffold/service_config.py

@@ -1,17 +1,21 @@
 # Wraps the .config.yml file in the service folder
 import hashlib
-import os
 import pdb
+import re
 
 from .config import Config
 from .constants import (
   SERVICE_DETACHED_ENV,
   SERVICE_HOSTNAME_ENV,
   SERVICE_ID_ENV,
+  SERVICE_LOCAL_ENV,
+  SERVICE_NAME_ENV,
   SERVICE_PRIORITY_ENV,
   SERVICE_PORT_ENV,
-  SERVICE_PROXY_MODE_ENV,
-  SERVICE_SCHEME_ENV
+  SERVICE_SCHEME_ENV,
+  SERVICE_UPSTREAM_HOSTNAME_ENV,
+  SERVICE_UPSTREAM_PORT_ENV,
+  SERVICE_UPSTREAM_SCHEME_ENV,
 )
 
 class ServiceConfig(Config):
@@ -21,10 +25,14 @@ class ServiceConfig(Config):
 
     self.__detached = None
     self.__hostname = None
+    self.__local = None
+    self.__name = None
     self.__port = None
     self.__priority = None
-    self.__proxy_mode = None
     self.__scheme = None
+    self.__upstream_hostname = None
+    self.__upstream_port = None
+    self.__upstream_scheme = None
 
     self.load()
 
@@ -34,18 +42,32 @@ class ServiceConfig(Config):
     if 'hostname' in kwargs:
       self.__hostname = kwargs.get('hostname')
 
+    if 'local' in kwargs:
+      self.__local = kwargs.get('local')
+
+    if 'name' in kwargs:
+      self.__name = kwargs.get('name')
+    elif 'service_name' in kwargs:
+      self.__name = kwargs.get('service_name')
+
     if 'port' in kwargs:
       self.__port = kwargs.get('port')
 
     if 'priority' in kwargs:
       self.__priority = kwargs.get('priority')
 
-    if 'proxy_mode' in kwargs:
-      self.__proxy_mode = kwargs.get('proxy_mode')
-
     if 'scheme' in kwargs:
       self.__scheme = kwargs.get('scheme')
 
+    if 'upstream_hostname' in kwargs:
+      self.__upstream_hostname = kwargs.get('upstream_hostname')
+
+    if 'upstream_port' in kwargs:
+      self.__upstream_port = kwargs.get('upstream_port')
+
+    if 'upstream_scheme' in kwargs:
+      self.__upstream_scheme = kwargs.get('upstream_scheme')
+
   @property
   def detached(self) -> bool:
     return not not self.__detached
@@ -66,12 +88,36 @@ class ServiceConfig(Config):
   def hostname(self, v):
     self.__hostname = v
 
+  @property
+  def local(self):
+    return self.__local
+
+  @local.setter
+  def local(self, v: bool):
+    self.__local = not not v
+
+  @property
+  def name(self):
+    return self.__name
+
+  @name.setter
+  def name(self, v: str):
+    if not v:
+      return
+
+    SERVICE_NAME_PATTERN = re.compile(r'^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$')
+
+    if not bool(SERVICE_NAME_PATTERN.fullmatch(v)):
+      raise ValueError(f"{v} must match {SERVICE_NAME_PATTERN}")
+
+    self.__name = v
+
   @property
   def port(self) -> int:
     if not self.__port:
-      if self.scheme == 'https':
+      if self.__scheme == 'https':
         return 443
-      elif self.scheme == 'http':
+      elif self.__scheme == 'http':
         return 80
 
     return self.__port
@@ -83,6 +129,8 @@ class ServiceConfig(Config):
     else:
       v = int(v)
       if v > 0 and v <= 65535:
+        if v == self.__upstream_port and self.local:
+          raise ValueError('port cannot be the same as upstream port')
         self.__port = v
 
   @property
@@ -100,14 +148,59 @@ class ServiceConfig(Config):
     self.__priority = v
 
   @property
-  def proxy_mode(self) -> str:
-    if self.__proxy_mode:
-      return (self.__proxy_mode or '').strip()
+  def scheme(self):
+    if not self.__scheme and self.__port:
+      if self.port == 443:
+        return 'https'
+      else:
+        return 'http'
+
+    return (self.__scheme or 'https').strip()
+
+  @scheme.setter
+  def scheme(self, v):
+    if v and not v in ['http', 'https']:
+      raise ValueError('scheme must be http or https')
+    self.__scheme = v
+
+  @property
+  def tls(self) -> bool:
+    return self.__scheme == 'https'
 
-    if not self.hostname:
-      return ''
+  @property
+  def upstream_hostname(self) -> int:
+    if self.local:
+      return 'host.docker.internal'
+    return self.__upstream_hostname or self.hostname
 
-    return f"reverse:{self.url}"
+  @upstream_hostname.setter
+  def upstream_hostname(self, v: str):
+    self.__upstream_hostname = v
+
+  @property
+  def upstream_port(self) -> int:
+    return self.__upstream_port or self.port
+
+  @upstream_port.setter
+  def upstream_port(self, v: int):
+    if v == None:
+      self.__upstream_port = v
+    else:
+      v = int(v)
+      if v > 0 and v <= 65535:
+        if v == self.__port and self.local:
+          raise ValueError('upstream port cannot be the same as port')
+        self.__upstream_port = v
+      else:
+        raise ValueError('upstream port must be between 0 and 65535')
+
+  @property
+  def upstream_scheme(self):
+    return self.__upstream_scheme or self.scheme
+
+  @upstream_scheme.setter
+  def upstream_scheme(self, v): 
+    self.__upstream_scheme = v
 
   @property
   def url(self):
@@ -124,40 +217,32 @@ class ServiceConfig(Config):
 
     return f"{_url}:{self.port}"
 
-  @proxy_mode.setter
-  def proxy_mode(self, v):
-    self.__proxy_mode = v
-
-  @property
-  def scheme(self):
-    return (self.__scheme or 'https').strip()
-
-  @scheme.setter
-  def scheme(self, v):
-    self.__scheme = v
-
-  @property
-  def tls(self) -> bool:
-    return self.__scheme == 'https'
-
   def load(self, config = None):
     config = config or self.read()
 
     self.detached = config.get(SERVICE_DETACHED_ENV)
     self.hostname = config.get(SERVICE_HOSTNAME_ENV)
+    self.local = config.get(SERVICE_LOCAL_ENV)
+    self.name = config.get(SERVICE_NAME_ENV)
     self.port = config.get(SERVICE_PORT_ENV)
     self.priority = config.get(SERVICE_PRIORITY_ENV)
-    self.proxy_mode = config.get(SERVICE_PROXY_MODE_ENV)
     self.scheme = config.get(SERVICE_SCHEME_ENV)
+    self.upstream_hostname = config.get(SERVICE_UPSTREAM_HOSTNAME_ENV)
+    self.upstream_port = config.get(SERVICE_UPSTREAM_PORT_ENV)
+    self.upstream_scheme = config.get(SERVICE_UPSTREAM_SCHEME_ENV)
 
   def to_dict(self):
     return {
       'detached': self.detached,
       'hostname': self.hostname,
+      'local': self.local,
+      'name': self.name,
       'port': self.port,
       'priority': self.priority,
-      'proxy_mode': self.proxy_mode,
       'scheme': self.scheme if self.hostname else '',
+      'upstream_hostname': self.upstream_hostname,
+      'upstream_port': self.upstream_port,
+      'upstream_scheme': self.upstream_scheme,
     }
 
   def write(self):
@@ -166,6 +251,12 @@ class ServiceConfig(Config):
     if self.hostname:
       config[SERVICE_HOSTNAME_ENV] = self.hostname
 
+    if self.local:
+      config[SERVICE_LOCAL_ENV] = True
+
+    if self.name:
+      config[SERVICE_NAME_ENV] = self.name
+
     if self.port:
       config[SERVICE_PORT_ENV] = self.port
 
@@ -175,8 +266,16 @@ class ServiceConfig(Config):
     if self.scheme:
       config[SERVICE_SCHEME_ENV] = self.scheme
 
+    if self.upstream_hostname:
+      config[SERVICE_UPSTREAM_HOSTNAME_ENV] = self.upstream_hostname
+
+    if self.upstream_port:
+      config[SERVICE_UPSTREAM_PORT_ENV] = self.upstream_port
+
+    if self.upstream_scheme:
+      config[SERVICE_UPSTREAM_SCHEME_ENV] = self.upstream_scheme
+
     config[SERVICE_DETACHED_ENV] = bool(self.detached)
     config[SERVICE_ID_ENV] = self.id
-    config[SERVICE_PROXY_MODE_ENV] = self.proxy_mode
 
     super().write(config)

stoobly_agent/app/cli/scaffold/service_create_command.py

@@ -2,6 +2,8 @@ import os
 import pdb
 import shutil
 
+from copy import deepcopy
+
 from .app import App
 from .constants import WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
 from .docker.service.builder import ServiceBuilder
@@ -14,8 +16,13 @@ class ServiceCreateCommand(ServiceCommand):
   def __init__(self, app: App, **kwargs):
     super().__init__(app, **kwargs)
 
+    self.__upstream_port = kwargs.get('upstream_port') or []
     self.__env_vars = kwargs.get('env') or []
-    self.__workflows = kwargs.get('workflow') or []
+    self.__workflows = kwargs.get('workflow') or [WORKFLOW_RECORD_TYPE, WORKFLOW_MOCK_TYPE, WORKFLOW_TEST_TYPE]
+
+  @property
+  def upstream_port(self):
+    return self.__upstream_port
 
   @property
   def env_vars(self):
@@ -45,7 +52,9 @@ class ServiceCreateCommand(ServiceCommand):
       self.__build_with_mock_workflow(service_builder, **workflow_kwargs)
 
     if WORKFLOW_RECORD_TYPE in self.workflows:
-      self.__build_with_record_workflow(service_builder, **workflow_kwargs)
+      service_builder_copy = deepcopy(service_builder)
+      service_builder_copy.with_upstream_port(self.upstream_port)
+      self.__build_with_record_workflow(service_builder_copy, **workflow_kwargs)
 
     if WORKFLOW_TEST_TYPE in self.workflows:
       self.__build_with_test_workflow(service_builder, **workflow_kwargs)

stoobly_agent/app/cli/scaffold/service_dependency.py

@@ -0,0 +1,51 @@
+import pdb
+import re
+
+from typing import Optional
+
+class ServiceDependency():
+    def __init__(self, s: str):
+      parts = s.rsplit(":", 2)  # split from the right, at most twice
+      if len(parts) != 3:
+          raise ValueError(f"Invalid format: {s}. Expected 'IMAGE:HOSTNAME:PORT'")
+      
+      self.image, self.hostname, self.port = parts
+      
+      # Basic validation
+      if not self.image:
+          raise ValueError("Image name cannot be empty")
+      if not self.hostname:
+          raise ValueError("Hostname cannot be empty")
+      if not self.port.isdigit():
+          raise ValueError(f"Port must be a number, got: {self.port}")
+      
+      self.port = int(self.port)
+    
+    def __repr__(self):
+        return f"ImageHostPort(image='{self.image}', hostname='{self.hostname}', port={self.port})"
+
+    @property
+    def image_name(self):
+        return DockerImage(self.image).name
+
+class DockerImage:
+    def __init__(self, ref: str):
+        # Regex based on Docker image spec
+        pattern = r"""
+            ^(?:(?P<registry>[^/]+?)/)?     # optional registry (no slash)
+            (?P<name>[^:@]+(?:/[^:@]+)*)    # image name (can have slashes)
+            (?::(?P<tag>[^@]+))?             # optional :tag
+            (?:@(?P<digest>.+))?             # optional @digest
+        """
+        match = re.match(pattern, ref, re.VERBOSE)
+        if not match:
+            raise ValueError(f"Invalid Docker image reference: {ref}")
+        
+        self.registry: Optional[str] = match.group("registry")
+        self.name: str = match.group("name")
+        self.tag: Optional[str] = match.group("tag")
+        self.digest: Optional[str] = match.group("digest")
+
+    def __repr__(self):
+        return (f"DockerImage(registry={self.registry!r}, "
+                f"name={self.name!r}, tag={self.tag!r}, digest={self.digest!r})")

stoobly_agent/app/cli/scaffold/service_docker_compose.py

@@ -1,6 +1,6 @@
+from stoobly_agent.app.cli.scaffold.constants import SERVICES_NAMESPACE
 from stoobly_agent.config.data_dir import DataDir
 
-
 class ServiceDockerCompose():
   def __init__(self, app_dir_path, target_workflow_name, service_name, hostname):
     self.service_name = service_name
@@ -11,5 +11,5 @@ class ServiceDockerCompose():
     self.configure_container_name = f"{target_workflow_name}-{service_name}.configure-1"
 
     data_dir_path = DataDir.instance(app_dir_path).path
-    self.docker_compose_path = f"{data_dir_path}/docker/{service_name}/{target_workflow_name}/docker-compose.yml"
-    self.init_script_path = f"{data_dir_path}/docker/{service_name}/{target_workflow_name}/bin/init"
+    self.docker_compose_path = f"{data_dir_path}/{SERVICES_NAMESPACE}/{service_name}/{target_workflow_name}/docker-compose.yml"
+    self.init_script_path = f"{data_dir_path}/{SERVICES_NAMESPACE}/{service_name}/{target_workflow_name}/bin/init"

stoobly_agent/app/cli/scaffold/service_workflow_validate_command.py

@@ -12,11 +12,12 @@ from docker.models.containers import Container
 
 from stoobly_agent.app.cli.scaffold.constants import (
   PUBLIC_FOLDER_NAME,
+  SERVICES_NAMESPACE,
   STOOBLY_DATA_DIR,
   WORKFLOW_RECORD_TYPE,
   WORKFLOW_TEST_TYPE,
 )
-from stoobly_agent.app.cli.scaffold.docker.constants import APP_EGRESS_NETWORK_TEMPLATE
+from stoobly_agent.app.cli.scaffold.docker.constants import APP_INGRESS_NETWORK_TEMPLATE
 from stoobly_agent.app.cli.scaffold.hosts_file_manager import HostsFileManager
 from stoobly_agent.app.cli.scaffold.service_command import ServiceCommand
 from stoobly_agent.app.cli.scaffold.service_docker_compose import ServiceDockerCompose
@@ -118,12 +119,14 @@ class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
     print(f"Validating hostname inside Docker network, url: {url}")
     
     # See WorkflowRunCommand for how 'network' is generated
+    # Debug command=f"curl -k --max-time {timeout_seconds} {url} --verbose",
     network = f"{self.workflow_name}.{self.app.network}" 
     timeout_seconds = 1
+    http_code_format = '"%{http_code}"'
     output = self.docker_client.containers.run(
       image='curlimages/curl:8.11.0',
-      command=f"curl --max-time {timeout_seconds} {url} --verbose",
-      network=APP_EGRESS_NETWORK_TEMPLATE.format(network=network),
+      command=f"curl -k -s -o /dev/null -w {http_code_format} --max-time {timeout_seconds} {url}",
+      network=APP_INGRESS_NETWORK_TEMPLATE.format(network=network),
       stderr=True,
       remove=True,
     )
@@ -131,7 +134,7 @@ class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
     # Note: 499 error could also mean success because it shows the proxy
     # connection is working, but we haven't recorded anything yet
     logs = output.decode('ascii')
-    if ('200 OK' not in logs) and ('499' not in logs):
+    if logs != '200' and  logs != '499':
       raise ScaffoldValidateException(f"Error reaching {url} from inside Docker network")
 
   # Check public folder exists in container
@@ -190,14 +193,14 @@ class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
   def validate(self) -> bool:
     print(f"Validating service: {self.service_name}")
 
-    url = f"{self.service_config.scheme}://{self.hostname}"
+    url = self.service_config.url
 
     if self.service_config.hostname and self.workflow_name not in [WORKFLOW_TEST_TYPE]:
       self.validate_hostname(self.hostname, self.service_config.port)
     
     # Test workflow won't expose services that are detached and have a hostname to the host such as assets.
     # Need to test connection from inside the Docker network
-    if self.service_config.hostname and self.workflow_name == WORKFLOW_TEST_TYPE and self.service_config.detached:
+    if self.service_config.hostname and self.workflow_name == WORKFLOW_TEST_TYPE:
       self.validate_internal_hostname(url)
 
     self.validate_init_containers(self.service_docker_compose.init_container_name, self.service_docker_compose.configure_container_name)
@@ -231,7 +234,7 @@ class ServiceWorkflowValidateCommand(ServiceCommand, ValidateCommand):
     if self.is_local():
       print(f"Validating local user defined service: {self.service_name}")
       # Validate docker-compose path exists
-      docker_compose_path = f"{self.app_dir_path}/{DATA_DIR_NAME}/docker/{self.service_docker_compose.service_name}/{self.workflow_name}/docker-compose.yml"
+      docker_compose_path = f"{self.app_dir_path}/{DATA_DIR_NAME}/{SERVICES_NAMESPACE}/{self.service_docker_compose.service_name}/{self.workflow_name}/docker-compose.yml"
       destination_path = Path(docker_compose_path)
 
       if not destination_path.exists():

stoobly_agent/app/cli/scaffold/templates/app/.Dockerfile.context

@@ -1,4 +1,4 @@
-FROM stoobly/agent:1.9
+FROM stoobly/agent:1.10
 
 ARG USER_ID
 

stoobly_agent/app/cli/scaffold/templates/app/build/.docker-compose.base.yml

@@ -6,7 +6,7 @@ services:
     extends:
       file: ../.docker-compose.base.yml
       service: context_base
-    working_dir: /home/stoobly/.stoobly/docker/${SERVICE_NAME}/${WORKFLOW_NAME}
+    working_dir: /home/stoobly/.stoobly/services/${SERVICE_NAME}/${WORKFLOW_NAME}
   build.init_base:
     command: 
     - ${SERVICE_SCRIPTS}/${SERVICE_NAME}/${WORKFLOW_TEMPLATE}/.init
@@ -16,4 +16,4 @@ services:
       service: context_base
     volumes:
     - ${APP_DIR}:/app
-    working_dir: /home/stoobly/.stoobly/docker/${SERVICE_NAME}/${WORKFLOW_NAME}
+    working_dir: /home/stoobly/.stoobly/services/${SERVICE_NAME}/${WORKFLOW_NAME}

stoobly_agent/app/cli/scaffold/templates/app/build/mock/bin/configure

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-# Add custom configuration here
+# Add custom Stoobly configuration here, to learn more: https://docs.stoobly.com/core-concepts/agent/proxy-settings