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

stoobly_agent/app/cli/scaffold/local/workflow/run_command.py

@@ -0,0 +1,339 @@
+import os
+import pdb
+import signal
+import subprocess
+import sys
+
+from typing import Optional, List
+
+from stoobly_agent.app.cli.scaffold.constants import PLUGIN_CYPRESS, PLUGIN_PLAYWRIGHT
+from stoobly_agent.app.cli.scaffold.docker.constants import PLUGIN_CONTAINER_SERVICE_TEMPLATE
+from stoobly_agent.app.cli.scaffold.templates.constants import CORE_BUILD_SERVICE_NAME, CORE_ENTRYPOINT_SERVICE_NAME, CUSTOM_CONFIGURE, CUSTOM_INIT, CUSTOM_RUN, MAINTAINED_CONFIGURE, MAINTAINED_INIT, MAINTAINED_RUN
+from stoobly_agent.app.cli.scaffold.workflow_run_command import WorkflowRunCommand
+from stoobly_agent.app.cli.types.workflow_run_command import WorkflowUpOptions, WorkflowDownOptions, WorkflowLogsOptions
+from stoobly_agent.lib.logger import Logger
+
+LOG_ID = 'LocalWorkflowRunCommand'
+
+class LocalWorkflowRunCommand(WorkflowRunCommand):
+  """Local workflow run command that executes stoobly-agent run directly."""
+
+  def __init__(self, app, services=None, script=None, **kwargs):
+    super().__init__(app, **kwargs)
+    
+    self.services = services or []
+    self.script = script
+
+    self._log_file_path = None
+    self._pid_file_path = None
+
+  @property
+  def log_file_path(self):
+    """Get the path to the PID file for this workflow."""
+    if not self._log_file_path:
+      self._log_file_path = os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.log")
+    return self._log_file_path
+
+  @property
+  def pid_file_path(self):
+    """Get the path to the PID file for this workflow."""
+    if not self._pid_file_path:
+      self._pid_file_path = os.path.join(self.workflow_namespace.path, f"{self.workflow_name}.pid")
+    return self._pid_file_path
+
+  def _write_pid(self, pid: int):
+    """Write the process PID to the PID file."""
+    os.makedirs(os.path.dirname(self.pid_file_path), exist_ok=True)
+    with open(self.pid_file_path, 'w') as f:
+      f.write(str(pid))
+
+  def _read_pid(self) -> Optional[int]:
+    """Read the process PID from the PID file."""
+    if not os.path.exists(self.pid_file_path):
+      return None
+    
+    try:
+      with open(self.pid_file_path, 'r') as f:
+        return int(f.read().strip())
+    except (ValueError, IOError):
+      return None
+
+  def _kill_process(self, pid: int, signal_type=signal.SIGTERM):
+    """Kill a process by PID."""
+    try:
+      os.kill(pid, signal_type)
+      return True
+    except (OSError, ProcessLookupError):
+      return False
+
+  def _is_process_running(self, pid: int) -> bool:
+    """Check if a process is still running."""
+    try:
+      os.kill(pid, 0)  # Signal 0 doesn't kill the process, just checks if it exists
+      return True
+    except (OSError, ProcessLookupError):
+      return False
+
+  def exec_service_script(self, service_name: str, step_script_path: str, args: List[str], cwd = None):
+    workflow_path = cwd or os.path.join(self.app.scaffold_namespace_path, service_name, self.workflow_name)
+
+    # Change directory to workflow path
+    command = [step_script_path] + args
+    if self.script:
+      command = [f"cd \"{workflow_path}\";"] + command
+
+    # Write the command to self.script_path
+    if self.script:
+      print(' '.join(command), file=self.script)
+
+    if self.dry_run:
+      print(' '.join(command))
+    else:
+      result = subprocess.run(['sh', '-c', ' '.join(command)], cwd=workflow_path)
+      if result.returncode != 0:
+        sys.exit(1)
+
+  def service_up(self, **options: WorkflowUpOptions):
+    print_service_header = options.get('print_service_header')
+    service_name = self.service_name
+    workflow_template = self.workflow_template
+
+    if print_service_header:
+      print_service_header(service_name)
+
+    self.write_env(**options)
+
+    # If service is build or entrypoint, use path in templates/build/services/SERVICE_NAME/.init
+    if service_name in [CORE_BUILD_SERVICE_NAME, CORE_ENTRYPOINT_SERVICE_NAME]:
+      init_script_path = os.path.join(self.service_templates_root_dir, service_name, workflow_template, MAINTAINED_INIT)
+      configure_script_path = os.path.join(self.service_templates_root_dir, service_name, workflow_template, MAINTAINED_CONFIGURE)
+      run_script_path = os.path.join(self.workflow_path, MAINTAINED_RUN)
+      
+      if not os.path.exists(run_script_path):
+        run_script_path = os.path.join(self.service_templates_root_dir, service_name, workflow_template, MAINTAINED_RUN)
+    else:
+      # Absolute path to workflow .init script
+      # e.g. stoobly_agent/app/cli/scaffold/templates/build/workflows/record/.init
+      init_script_path = os.path.join(self.workflow_templates_build_dir, MAINTAINED_INIT)
+
+      # Absolute path to workflow .configure script
+      # e.g. stoobly_agent/app/cli/scaffold/templates/build/workflows/record/.configure
+      configure_script_path = os.path.join(self.workflow_templates_build_dir, MAINTAINED_CONFIGURE)
+
+      run_script_path = os.path.join(self.workflow_templates_build_dir, MAINTAINED_RUN)
+
+    self.exec_service_script(service_name, init_script_path, [CUSTOM_INIT])
+    self.exec_service_script(service_name, configure_script_path, [CUSTOM_CONFIGURE])
+    self.exec_service_script(service_name, run_script_path, [CUSTOM_RUN], cwd=os.getcwd())
+
+  def up(self, **options: WorkflowUpOptions):
+    """Start the workflow using local stoobly-agent run."""
+    detached = options.get('detached', False)
+
+    commands = self.workflow_service_commands(**options)
+
+    # iterate through each service in the workflow
+    public_directory_paths = []
+    response_fixtures_paths = []
+    for command in commands:
+      url = command.service_config.url
+      if url:
+        if os.path.exists(command.public_dir_path):
+          public_directory_paths.append('--public-directory-path')
+          public_directory_paths.append(f"{command.public_dir_path}:{url}")
+
+        if os.path.exists(command.response_fixtures_path):
+          response_fixtures_paths.append('--response-fixtures-path')
+          response_fixtures_paths.append(f"{command.response_fixtures_path}:{url}")
+    
+    # Check if PID file already exists
+    if os.path.exists(self.pid_file_path):
+      pid = self._read_pid()
+      if pid and self._is_process_running(pid):
+        Logger.instance(LOG_ID).error(f"Workflow {self.workflow_name} is already running with PID: {pid}")
+        Logger.instance(LOG_ID).error(f"Run `stoobly-agent scaffold workflow down {self.workflow_name}` to stop it first")
+        sys.exit(1)
+      else:
+        # PID file exists but process is not running, clean it up
+        os.remove(self.pid_file_path)
+
+    for command in commands:
+      command.service_up(**options)
+
+      # If second from last command, run up_command i.e. right before entrypoint
+      if command == commands[-2]:
+        self.__up_command(public_directory_paths, response_fixtures_paths, **options)
+
+  def down(self, **options: WorkflowDownOptions):
+    """Stop the workflow by killing the local process."""
+    
+    pid = self._read_pid()
+    if not pid:
+      Logger.instance(LOG_ID).warning(f"No PID file found for {self.workflow_name}")
+      return
+    
+    if not self._is_process_running(pid):
+      Logger.instance(LOG_ID).info(f"Process {pid} for {self.workflow_name} is not running")
+      # Clean up PID file
+      if os.path.exists(self.pid_file_path):
+        os.remove(self.pid_file_path)
+      return
+    
+    # Kill the process
+    if self.script:
+      self.__dry_run_down(pid, self.script)
+
+    if self.dry_run:
+      self.__dry_run_down(pid, sys.stdout)
+    else:
+      try:
+        # Try graceful shutdown first with SIGTERM
+        Logger.instance(LOG_ID).info(f"Sending SIGTERM to process {pid} for {self.workflow_name}")
+        self._kill_process(pid, signal.SIGTERM)
+ 
+        # Wait a bit for graceful shutdown
+        import time
+        time.sleep(2)
+        
+        # Check if process still exists
+        if self._is_process_running(pid):
+          Logger.instance(LOG_ID).info(f"Process {pid} still running, sending SIGKILL")
+          self._kill_process(pid, signal.SIGKILL)
+          
+          # Wait a bit more for SIGKILL to take effect
+          time.sleep(1)
+          
+          # Final check
+          if self._is_process_running(pid):
+            Logger.instance(LOG_ID).warning(f"Process {pid} may still be running after SIGKILL")
+          else:
+            Logger.instance(LOG_ID).info(f"Successfully stopped process {pid} for {self.workflow_name}")
+        else:
+          Logger.instance(LOG_ID).info(f"Successfully stopped process {pid} for {self.workflow_name}")
+        
+        # Clean up PID file
+        if os.path.exists(self.pid_file_path):
+          os.remove(self.pid_file_path)
+          
+      except Exception as e:
+        Logger.instance(LOG_ID).error(f"Failed to stop {self.workflow_name}: {e}")
+
+  def logs(self, **options: WorkflowLogsOptions):
+    """Show logs for the local workflow process."""
+    follow = options.get('follow', False)
+    
+    pid = self._read_pid()
+    if not pid:
+      Logger.instance(LOG_ID).warning(f"No PID file found for {self.workflow_name}")
+      return
+    
+    # Build log command
+    log_file = f"{self.log_file_path}"
+    if self.script:
+      self.__dry_run_logs(log_file, self.script, follow)
+
+    if self.dry_run:
+      self.__dry_run_logs(log_file, sys.stdout, follow)
+    else:
+      try:
+        if follow:
+          subprocess.run(['tail', '-f', log_file])
+        else:
+          subprocess.run(['cat', log_file])
+      except subprocess.CalledProcessError as e:
+        Logger.instance(LOG_ID).error(f"Failed to show logs for {self.workflow_name}: {e}")
+
+  def status(self):
+    """Check the status of the local workflow process."""
+    pid = self._read_pid()
+    if not pid:
+      return "not running"
+    
+    if self._is_process_running(pid):
+      return f"running (PID: {pid})"
+    else:
+      return "not running (stale PID file)"
+
+  def workflow_service_commands(self, **options: WorkflowUpOptions):
+    commands = list(map(lambda service_name: LocalWorkflowRunCommand(self.app, service_name=service_name, **options), self.services))
+    commands.sort(key=lambda command: command.service_config.priority)
+    return commands
+
+  def __dry_run_down(self, pid: int, output_file: str):
+    print(f"# Stop {self.workflow_name} (PID: {pid})", file=output_file)
+    print(f"kill {pid} || true", file=output_file)
+    print("sleep 1", file=output_file)
+    print(f"kill -0 {pid} 2>/dev/null && kill {pid} || true", file=output_file)
+    print(f"rm -f {self.pid_file_path}", file=output_file)
+
+  def __dry_run_logs(self, log_file: str, output_file: str, follow: bool):
+    print(f"# Show logs for {self.workflow_name}", file=output_file)
+    if follow:
+      print(f"tail -f {log_file}", file=output_file)
+    else:
+      print(f"cat {log_file}", file=output_file)
+
+  def __up_command(self, public_directory_paths: List[str], response_fixtures_paths: List[str], **options: WorkflowUpOptions):
+    # Build the stoobly-agent run command
+    command = ['stoobly-agent', 'run']
+
+    # Add log level if provided
+    if options.get('log_level'):
+      command.extend(['--log-level', options['log_level']])
+    
+    # Use the PID file path as the detached output file
+    command.extend(['--detached', self.log_file_path])
+
+    command.extend(['--proxy-port', f"{self.app_config.proxy_port}"])
+    command.extend(['--ui-port', f"{self.app_config.ui_port}"])
+
+    if public_directory_paths:
+      command.extend(public_directory_paths)
+
+    if response_fixtures_paths:
+      command.extend(response_fixtures_paths)
+    
+    # Convert command to string
+    command_str = ' '.join(command)
+
+    # Run in background using the main run command's --detached option
+    if self.script:
+      # Write to script for detached execution
+      script_lines = [
+        f"# Start {self.workflow_name} in background using --detached",
+        f"{command_str} > {self.pid_file_path}",
+        f"echo \"Started {self.workflow_name} with PID: $(cat {self.pid_file_path})\""
+      ]
+      for line in script_lines:
+        print(line, file=self.script)
+
+    if self.dry_run:
+      print(command_str)
+    else:
+      # Execute directly
+      try:
+        # Run the command with --detached option
+        result = subprocess.run(
+          command,
+          capture_output=True,
+          text=True,
+          check=True
+        )
+
+        if result.returncode != 0:
+          Logger.instance(LOG_ID).error(f"Failed to start agent, run `stoobly-agent workflow logs {self.workflow_name}` to see the error")
+          sys.exit(1)
+        
+        # The --detached option prints the PID to stdout
+        pid = int(result.stdout.strip())
+        
+        # Write PID to file
+        self._write_pid(pid)
+        
+        Logger.instance(LOG_ID).info(f"Started {self.workflow_name} with PID: {pid}")
+      except subprocess.CalledProcessError as e:
+        Logger.instance(LOG_ID).error(f"Failed to start {self.workflow_name}: {e}")
+        return None
+      except ValueError as e:
+        Logger.instance(LOG_ID).error(f"Failed to parse PID from output: {e}")
+        return None

stoobly_agent/app/cli/scaffold/service_command.py

@@ -12,10 +12,14 @@ class ServiceCommand(AppCommand):
     super().__init__(app)
     self.__service_name = kwargs.get('service_name')
 
-    self.__config = ServiceConfig(self.service_path, **kwargs)
+    if kwargs.get('service_name'):
+      self.__config = ServiceConfig(self.service_path, **kwargs)
 
   @property
   def service_config(self):
+    if not self.service_name:
+      raise Exception("Service name is required")
+
     return self.__config
 
   @service_config.setter
@@ -52,6 +56,10 @@ class ServiceCommand(AppCommand):
       self.service_name,
     )
 
+  @property
+  def service_templates_root_dir(self):
+    return os.path.join(self.templates_root_dir, 'build', 'services')
+
   def config(self, _c: dict):
     _config = self.app_config.read()
     _config.update(self.service_config.read())

stoobly_agent/app/cli/scaffold/service_config.py

@@ -1,5 +1,6 @@
 # Wraps the .config.yml file in the service folder
 import hashlib
+import os
 import pdb
 import re
 
@@ -12,7 +13,6 @@ from .constants import (
   SERVICE_NAME_ENV,
   SERVICE_PRIORITY_ENV,
   SERVICE_PORT_ENV,
-  SERVICE_PROXY_MODE_ENV,
   SERVICE_SCHEME_ENV,
   SERVICE_UPSTREAM_HOSTNAME_ENV,
   SERVICE_UPSTREAM_PORT_ENV,
@@ -30,7 +30,6 @@ class ServiceConfig(Config):
     self.__name = None
     self.__port = None
     self.__priority = None
-    self.__proxy_mode = None
     self.__scheme = None
     self.__upstream_hostname = None
     self.__upstream_port = None
@@ -58,9 +57,6 @@ class ServiceConfig(Config):
     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')
 
@@ -73,6 +69,10 @@ class ServiceConfig(Config):
     if 'upstream_scheme' in kwargs:
       self.__upstream_scheme = kwargs.get('upstream_scheme')
 
+  @property
+  def app_config_dir_path(self):
+    return os.path.dirname(self.dir)
+
   @property
   def detached(self) -> bool:
     return not not self.__detached
@@ -152,22 +152,6 @@ class ServiceConfig(Config):
   def priority(self, v):
     self.__priority = v
 
-  @property
-  def proxy_mode(self) -> str:
-    if self.__proxy_mode:
-      return (self.__proxy_mode or '').strip()
-
-    if not self.hostname:
-      return ''
-
-    return 'regular'
-
-  @proxy_mode.setter
-  def proxy_mode(self, v: str):
-    if v and v not in ['regular', 'reverse']:
-      v = 'reverse' 
-    self.__proxy_mode = v
-
   @property
   def scheme(self):
     if not self.__scheme and self.__port:
@@ -221,10 +205,13 @@ class ServiceConfig(Config):
 
   @upstream_scheme.setter
   def upstream_scheme(self, v): 
-    self.__scheme = v
+    self.__upstream_scheme = v
 
   @property
   def url(self):
+    if not self.hostname:
+      return ''
+
     _url = f"{self.scheme}://{self.hostname}"
 
     if not self.port:
@@ -247,7 +234,6 @@ class ServiceConfig(Config):
     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)
@@ -261,7 +247,6 @@ class ServiceConfig(Config):
       '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,
@@ -300,6 +285,5 @@ class ServiceConfig(Config):
 
     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

@@ -3,10 +3,12 @@ import pdb
 import shutil
 
 from copy import deepcopy
+from typing import Union
 
 from .app import App
-from .constants import WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
-from .docker.service.builder import ServiceBuilder
+from .constants import RUN_ON_DOCKER, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
+from .local.service.builder import ServiceBuilder
+from .docker.service.builder import DockerServiceBuilder
 from .docker.workflow.decorators_factory import get_workflow_decorators
 from .service_command import ServiceCommand
 from .workflow_create_command import WorkflowCreateCommand
@@ -32,8 +34,18 @@ class ServiceCreateCommand(ServiceCommand):
   def workflows(self):
     return self.__workflows
 
+  @property
+  def create_docker_files(self):
+    """Determine if Docker files should be created based on app config run-on setting."""
+    return RUN_ON_DOCKER in self.app_config.run_on
+
   def build(self):
-    service_builder = ServiceBuilder(self.service_config)
+    # Choose builder based on app run_on configuration
+    if RUN_ON_DOCKER in self.app_config.run_on:
+      service_builder = DockerServiceBuilder(self.service_config)
+    else:
+      service_builder = ServiceBuilder(self.service_config)
+    
     service_builder.with_env(list(self.env_vars))
     service_decorators = []
 
@@ -67,19 +79,19 @@ class ServiceCreateCommand(ServiceCommand):
     if os.path.exists(dest):
       shutil.rmtree(dest)
 
-  def __build_with_mock_workflow(self, service_builder: ServiceBuilder, **kwargs):
+  def __build_with_mock_workflow(self, service_builder: Union[ServiceBuilder, DockerServiceBuilder], **kwargs):
     mock_workflow = WorkflowCreateCommand(self.app, **{ **kwargs, **{ 'workflow_name': WORKFLOW_MOCK_TYPE }})
 
     workflow_decorators = get_workflow_decorators(WORKFLOW_MOCK_TYPE, self.service_config)
     mock_workflow.build(service_builder=service_builder, workflow_decorators=workflow_decorators)
 
-  def __build_with_record_workflow(self, service_builder: ServiceBuilder, **kwargs):
+  def __build_with_record_workflow(self, service_builder: Union[ServiceBuilder, DockerServiceBuilder], **kwargs):
     record_workflow = WorkflowCreateCommand(self.app, **{ **kwargs, **{ 'workflow_name': WORKFLOW_RECORD_TYPE }})
 
     workflow_decorators = get_workflow_decorators(WORKFLOW_RECORD_TYPE, self.service_config)
     record_workflow.build(service_builder=service_builder, workflow_decorators=workflow_decorators)
 
-  def __build_with_test_workflow(self, service_builder: ServiceBuilder, **kwargs):
+  def __build_with_test_workflow(self, service_builder: Union[ServiceBuilder, DockerServiceBuilder], **kwargs):
     mock_workflow = WorkflowCreateCommand(self.app, **{ **kwargs, **{ 'workflow_name': WORKFLOW_TEST_TYPE }})
 
     workflow_decorators = get_workflow_decorators(WORKFLOW_TEST_TYPE, self.service_config)

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}/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/.Makefile

@@ -33,10 +33,10 @@ workflow=record
 workflow_service_options=$(shell echo $$STOOBLY_WORKFLOW_SERVICE_OPTIONS)
 
 app_data_dir=$(app_dir)/.stoobly
-app_namespace_dir=$(app_data_dir)/docker
+app_namespace_dir=$(app_data_dir)/services
 app_tmp_dir=$(app_data_dir)/tmp
 dockerfile_path=$(app_namespace_dir)/.Dockerfile.context
-exec_docker_compose_file_path=$(app_namespace_dir)/stoobly-ui/exec/.docker-compose.exec.yml
+exec_docker_compose_file_path=$(app_namespace_dir)/stoobly-ui/exec/.docker-compose.yml
 workflow_namespace=$(if $(namespace),$(namespace),$(workflow))
 workflow_namespace_dir=$(app_tmp_dir)/$(workflow_namespace)
 workflow_script=.stoobly/tmp/$(workflow_namespace)/run.sh

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

@@ -2,18 +2,18 @@ services:
   build.configure_base:
     command: 
     - ${SERVICE_SCRIPTS}/${SERVICE_NAME}/${WORKFLOW_TEMPLATE}/.configure
-    - bin/configure
+    - configure
     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
-    - bin/init
+    - init
     extends:
       file: ../.docker-compose.base.yml
       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/configure

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

stoobly_agent/app/cli/scaffold/templates/app/build/record/configure

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Add custom Stoobly configuration here, to learn more: https://docs.stoobly.com/core-concepts/agent/proxy-settings
+
+echo "Configuring rewrite rules..."
+stoobly-agent config rewrite set \
+  --method GET --method POST --method OPTIONS --method PUT --method DELETE \
+  --mode record \
+  --name authorization \
+  --pattern ".*" \
+  --type Header \
+  --value '' \
+
+stoobly-agent config rewrite set \
+  --method GET --method POST --method OPTIONS --method PUT --method DELETE \
+  --mode record \
+  --name cookie \
+  --pattern ".*" \
+  --type Header \
+  --value '' \
+
+stoobly-agent config rewrite set \
+  --method GET --method POST --method OPTIONS --method PUT --method DELETE \
+  --mode record \
+  --name set-cookie \
+  --pattern ".*" \
+  --type 'Response Header' \
+  --value '' \