stack-service-base 0.0.97 → 0.0.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a29686255562ea2b36806d5d50db270dda9c65d6b9d819f0f9c241a3a4f85049
-  data.tar.gz: 2e33c64c8f927a7ac034c39d2b2ea1b5118bedb3315d44d2265f80d463fafdad
+  metadata.gz: 3db078c7ea6acaca31ec7b32b7991fd213dcaacd03fcab42733f8f3d299b6456
+  data.tar.gz: 621b4b6c3b116f0f72555740ca83f9f62029e0a58b3d19655fdf77db45f27a5b
 SHA512:
-  metadata.gz: 0f8d15d2b3e8c33e8e321464df2068351da9e6fdb5b0439405635ed7876f4fb014d9525284a87c6237ee13c4731cc177ebfd0f5328f9d44fcc8a32b36f811ff9
-  data.tar.gz: ea9223839e6ccabe433121647be6a8c93ce62d6d807c482aad9c3a1fdf48b18a226a8d7eb1449b71c7ab93e41c4c390f7379d092e6403de8136d0249e3ce4647
+  metadata.gz: 0ecbb4d62eb789d83cbbc72d422ed7316a5ac486d1cf3dbcf538cd253aefb156d3dcb71b5937e5bd9f99e9360c10310fea242d42abda559532d2ba73594b9213
+  data.tar.gz: 4d3d7862b719bcb04d26881dada64385c2a61f3bcad4e1ce13d080b26249fb6accaa31bf650b820d5988de99c132570e09c03b19bbd74121f7f076af8f7b2f28

data/lib/stack-service-base/command_init.rb

@@ -66,7 +66,9 @@ SSBase::CommandLine::COMMANDS[:init] = Class.new do
 
   def update_service_name(s_name)
     $stdout.puts "Update service name: #{s_name}"
-    Dir.glob('**/*').each do |file|
+    Dir.glob('**/{*,.*}', File::FNM_DOTMATCH).each do |file|
+      path_parts = file.split('/')
+      next if path_parts[0...-1].any? { |part| part.start_with?('.') }
       next unless File.file? file
       content = File.read(file)
       include = content.include?('${service_name}') ? '(found)' : nil
@@ -80,5 +82,3 @@ SSBase::CommandLine::COMMANDS[:init] = Class.new do
   def help = ['Create basic service file structure',
               '[... to_compose <deploy name>] ']
 end.new
-
-

data/lib/stack-service-base/examples/mcp_config.ru

@@ -4,9 +4,9 @@ require 'stack-service-base'
 StackServiceBase.rack_setup self
 
 SERVICES = {
-  "database-backend" => {
-    status: "running",
-    uptime: 72 * 3600,                       # seconds
+  'database-backend' => {
+    status: 'running',
+    uptime: 72 * 3600, # seconds
     last_restart: Time.now - 72 * 3600
   }
 }
@@ -16,25 +16,54 @@ helpers McpHelper
 
 Tool :search do
   description 'Search for a term in the database'
-  input query: { type: "string", description: "Term to search for", required: true }
+  input query: { type: 'string', description: 'Term to search for', required: true }
   call do |inputs|
     query = inputs[:query]
-    { results: [{id:"doc-1",title:"...",url:"..."}] }
+    { results: [{id: 'doc-1', title: '...', url: '...'}] }
   end
 end
 
 Tool :fetch do
   description 'Fetch a resource from the database'
-  input resource_id: { type: "string", description: "Resource ID to fetch", required: true }
+  input resource_id: { type: 'string', description: 'Resource ID to fetch', required: true }
   call do |inputs|
     id = inputs[:id]
-    { id: "doc-1", title: "...", text: "full text...", url: "https://example.com/doc",  metadata: { source: "vector_store" } }
+    { id: 'doc-1', title: '...', text: 'full text...', url: 'https://example.com/doc', metadata: { source: 'vector_store' } }
+  end
+end
+
+Tool :schema_echo do
+  description 'Echo a value using a direct JSON schema'
+  input_schema type: 'object',
+               properties: {
+                 value: { type: 'string', description: 'Value to echo' }
+               },
+               required: ['value']
+  annotations readOnlyHint: true
+  call do |inputs|
+    { value: inputs[:value] }
+  end
+end
+
+Tool :full_response_echo do
+  description 'Echo a value using a complete MCP tool response'
+  input value: { type: 'string', description: 'Value to echo', required: true }
+  call do |inputs|
+    {
+      content: [
+        { type: 'text', text: inputs[:value] }
+      ],
+      structuredContent: {
+        value: inputs[:value]
+      },
+      isError: false
+    }
   end
 end
 
 Tool :service_status do
   description 'Check current status of a service'
-  input service_name: { type: "string", description: "Service name to inspect", required: true }
+  input service_name: { type: 'string', description: 'Service name to inspect', required: true }
   call do |inputs|
     service_name = inputs[:service_name]
     service = SERVICES[service_name]
@@ -50,14 +79,14 @@ end
 
 Tool :restart_service do
   description 'Restart a service'
-  input service_name: { type: "string", description: "Service name to restart", required: true },
-        force: { type: "boolean", default: false, description: "Force restart if graceful fails" }
+  input service_name: { type: 'string', description: 'Service name to restart', required: true },
+        force: { type: 'boolean', default: false, description: 'Force restart if graceful fails' }
   call do |inputs|
     service_name = inputs[:service_name]
     service = SERVICES[service_name]
     rpc_error!(-32000, "Unknown service #{service_name}") unless service
 
-    service[:status]       = "running"
+    service[:status]       = 'running'
     service[:last_restart] = Time.now
     service[:uptime]       = 0
     {

data/lib/stack-service-base/mcp/mcp_helper.rb

@@ -4,6 +4,21 @@ require_relative 'mcp_tool_registry'
 MCP_PROCESSOR = McpProcessor.new
 
 module McpHelper
+  VALID_TRANSPORTS = [:sse, :json].freeze
+
+  class << self
+    def transport
+      @transport ||= :sse
+    end
+
+    def transport=(value)
+      value = value.to_sym
+      raise ArgumentError, "Unknown MCP transport: #{value}" unless VALID_TRANSPORTS.include?(value)
+
+      @transport = value
+    end
+  end
+
   def self.included(base)
     base.class_eval do
 
@@ -18,28 +33,34 @@ module McpHelper
       end
 
       post '/mcp' do
-        content_type 'text/event-stream'
-        headers['Cache-Control'] = 'no-cache'
-        headers['X-Accel-Buffering'] = 'no'
-        headers['mcp-session-id'] = SecureRandom.uuid
         request.body&.rewind
-        body = request.body.read.to_s
 
         response_body =
           begin
-            MCP_PROCESSOR.rpc_endpoint(body)
+            MCP_PROCESSOR.rpc_endpoint(request.body.read.to_s)
           rescue McpProcessor::ParseError => e
             status e.status
             e.body
           end
 
-        LOGGER.debug "request body: #{body}"
-        LOGGER.debug "response body: #{response_body}"
+        if response_body.nil?
+          status 202
+          headers 'Content-Length' => '0'
+          ''
+        elsif McpHelper.transport == :json
+          content_type :json
+          response_body
+        else
+          content_type 'text/event-stream'
+          headers['Cache-Control'] = 'no-cache'
+          headers['X-Accel-Buffering'] = 'no'
+          headers['mcp-session-id'] = SecureRandom.uuid
 
-        stream true do |s|
-          s.callback { LOGGER.debug "stream closed: #{s}" }
-          s << "event: message\ndata: #{response_body}\n\n"
-          s.close
+          stream true do |s|
+            s.callback { LOGGER.debug "stream closed: #{s}" }
+            s << ['event: message', "data: #{response_body}", '', ''].join($/)
+            s.close
+          end
         end
       end
     end

data/lib/stack-service-base/mcp/mcp_processor.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 class JsonRpcError < StandardError
   attr_reader :code
 
@@ -15,6 +17,11 @@ end
 
 class McpProcessor
   PROTOCOL_VERSION = '2025-06-18'
+  DEFAULT_SERVER_INFO = {
+    name: 'mcp-server',
+    title: 'MCP Server',
+    version: '1.0.0'
+  }.freeze
 
   include RpcErrorHelpers
   ParseError = Class.new(StandardError) do
@@ -23,11 +30,13 @@ class McpProcessor
     def initialize(body:, status:)
       @body = body
       @status = status
-      super("MCP parse error")
+      super('MCP parse error')
     end
   end
 
-  def initialize(logger: LOGGER)
+  def initialize(registry: nil, server_info: DEFAULT_SERVER_INFO, logger: (defined?(LOGGER) ? LOGGER : nil))
+    @registry = registry
+    @server_info = server_info
     @logger = logger
   end
 
@@ -37,14 +46,22 @@ class McpProcessor
 
   def rpc_endpoint(raw_body)
     req = JSON.parse(raw_body.to_s)
-    rpc_response(id: req["id"], method: req["method"], params: req["params"])
-  rescue JSON::ParserError
-    body = error_response(id: nil, code: -32700, message: "Parse error")
+    method = req['method']
+    params = req['params']
+
+    if req.key?('id')
+      rpc_response(id: req['id'], method: method, params: params)
+    else
+      notification_response(method: method, params: params)
+    end
+  rescue JSON::ParserError => e
+    @logger&.warn("MCP JSON parse failed: #{e.message}")
+    body = error_response(id: nil, code: -32_700, message: 'Parse error')
     raise ParseError.new(body: body, status: 400)
   end
 
   def list_tools
-    { tools: ToolRegistry.list, nextCursor: 'no-more' }
+    { tools: registry.list, nextCursor: 'no-more' }
   end
 
   def root_response
@@ -56,32 +73,47 @@ class McpProcessor
   end
 
   def rpc_response(id:, method:, params:)
-    json_rpc_response(id: id) { |body| handle(method: method, params: params, body: body) }
+    json_rpc_response(id: id) { handle(method: method, params: params) }
+  end
+
+  def notification_response(method:, params:)
+    handle_notification(method: method, params: params)
+    nil
+  rescue => e
+    @logger&.error("Unhandled MCP notification error: #{e.class}: #{e.message}")
+    nil
   end
 
-  def handle(method:, params:, body: )
+  def handle(method:, params:)
     case method
-    when "tools/list"  then list_tools
-    # when "resources/list"  then {}
-    # when "prompts/list"  then {}
-    when "tools/call"  then call_tool(params || {})
-    when "initialize"  then initialize_(body)
-    when "notifications/initialized" then LOGGER.debug params; {}
-    when "logging/setLevel" then LOGGER.debug params; {}
+    when 'tools/list'  then list_tools
+    # when 'resources/list'  then {}
+    # when 'prompts/list'  then {}
+    when 'tools/call'  then call_tool(params || {})
+    when 'initialize'  then initialize_response
+    when 'notifications/initialized' then @logger&.debug(params); {}
+    when 'logging/setLevel' then @logger&.debug(params); {}
     else
-      rpc_error!(-32601, "Unknown method #{method}")
+      rpc_error!(-32_601, "Unknown method #{method}")
     end
   end
 
-  # https://gist.github.com/ruvnet/7b6843c457822cbcf42fc4aa635eadbb
+  def handle_notification(method:, params:)
+    case method
+    when 'notifications/initialized', 'notifications/cancelled'
+      @logger&.debug("MCP notification accepted: #{method}")
+    else
+      @logger&.debug("MCP notification ignored: #{method}")
+    end
+  end
 
-  def initialize_(body)
+  def initialize_(_body = nil)
+    initialize_response
+  end
+
+  def initialize_response
     {
-      serverInfo: {
-        name: 'mcp-server',
-        title: 'MCP Server',
-        version: '1.0.0'
-      },
+      serverInfo: @server_info,
       protocolVersion: PROTOCOL_VERSION,
       capabilities: {
         logging: {},
@@ -95,16 +127,16 @@ class McpProcessor
   private
 
   def json_rpc_response(id:)
-    body = { jsonrpc: "2.0", id: id }
+    body = { jsonrpc: '2.0', id: id }
 
     begin
-      result = yield(body)
+      result = yield
       body[:result] = result unless body[:error] || result.nil?
     rescue JsonRpcError => e
       body[:error] = { code: e.code, message: e.message }
     rescue => e
       @logger&.error("Unhandled RPC error: #{e.class}: #{e.message}\n#{e.backtrace&.first}")
-      body[:error] = { code: -32603, message: "Internal error" }
+      body[:error] = { code: -32_603, message: 'Internal error' }
     end
 
     body.delete(:result) if body[:error]
@@ -112,13 +144,31 @@ class McpProcessor
   end
 
   def call_tool(params)
-    name      = params["name"]
-    arguments = params["arguments"] || {}
-    tool      = ToolRegistry.fetch(name) || rpc_error!(-32601, "Unknown tool #{name}")
+    name      = params['name']
+    arguments = params['arguments'] || {}
+    tool      = registry.fetch(name) || rpc_error!(-32_601, "Unknown tool #{name}")
     response = tool.call_tool(arguments)
+    return response if mcp_tool_response?(response)
+
+    wrap_tool_response(response)
+  end
+
+  def registry
+    @registry || ToolRegistry.default
+  end
+
+  def mcp_tool_response?(response)
+    return false unless response.is_a?(Hash)
+
+    [:content, :structuredContent, :isError, 'content', 'structuredContent', 'isError'].any? do |key|
+      response.key?(key)
+    end
+  end
+
+  def wrap_tool_response(response)
     {
       content: [
-        { "type": "text", "text": response.is_a?(String) ? response : response.to_json }
+        { 'type' => 'text', 'text' => response.is_a?(String) ? response : JSON.dump(response) }
       ],
       isError: false
     }

data/lib/stack-service-base/mcp/mcp_tool_registry.rb

@@ -3,12 +3,35 @@ module ToolRegistry
     include RpcErrorHelpers
   end
 
+  class Registry
+    attr_reader :registry
+
+    def initialize
+      @registry = {}
+    end
+
+    def define(name, &block)
+      definition = Definition.new(name)
+      definition.instance_eval(&block)
+      @registry[definition.name] = definition
+    end
+
+    def list
+      registry.values.map(&:to_h)
+    end
+
+    def fetch(name)
+      registry[name.to_s]
+    end
+  end
+
   class Definition
     attr_reader :name
 
     def initialize(name)
       @name = name.to_s
       @inputs = {}
+      @annotations = {}
     end
 
     def description(text = nil)
@@ -20,62 +43,89 @@ module ToolRegistry
       @inputs.merge!(fields.transform_keys(&:to_s))
     end
 
-    def input_schema
-      properties = {}
-      required = []
+    def input_schema(schema = nil)
+      return @input_schema || build_input_schema if schema.nil?
 
-      @inputs.each do |field, config|
-        cfg = config.transform_keys { |key| key.is_a?(Symbol) ? key : key.to_sym }
-        required << field if cfg.delete(:required)
-        properties[field] = cfg.transform_keys(&:to_s)
-      end
+      @input_schema = stringify_keys(schema)
+    end
 
-      { type: 'object', properties: properties, required: required }
+    def annotations(value = nil)
+      return @annotations if value.nil?
+
+      @annotations = stringify_keys(value)
     end
 
     def call(&block) = @executor = block
 
     def to_h
-      {
+      payload = {
         name: name,
         description: description,
         inputSchema: input_schema
       }
+      payload[:annotations] = annotations unless annotations.empty?
+      payload
     end
 
     def call_tool(arguments)
-      raise JsonRpcError.new(code: 500, message: "Tool #{name} missing executor") unless @executor
+      raise JsonRpcError.new(code: -32603, message: "Tool #{name} missing executor") unless @executor
 
       ExecutionContext.new.instance_exec(symbolize_keys(arguments || {}), &@executor)
     end
 
     private
 
+    def build_input_schema
+      properties = {}
+      required = []
+
+      @inputs.each do |field, config|
+        cfg = stringify_keys(config)
+        required << field if cfg.delete('required')
+        properties[field] = cfg
+      end
+
+      { type: 'object', properties: properties, required: required }
+    end
+
     def symbolize_keys(hash)
       hash.each_with_object({}) do |(key, value), memo|
         memo[key.to_sym] = value
       end
     end
+
+    def stringify_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, item), memo| memo[key.to_s] = stringify_keys(item) }
+      when Array
+        value.map { |item| stringify_keys(item) }
+      else
+        value
+      end
+    end
   end
 
   module_function
 
+  def default
+    @default ||= Registry.new
+  end
+
   def define(name, &block)
-    definition = Definition.new(name)
-    definition.instance_eval(&block)
-    registry[definition.name] = definition
+    default.define(name, &block)
   end
 
   def registry
-    @registry ||= {}
+    default.registry
   end
 
   def list
-    registry.values.map(&:to_h)
+    default.list
   end
 
   def fetch(name)
-    registry[name.to_s]
+    default.fetch(name)
   end
 end
 

data/lib/stack-service-base/project_template/gitlab/.gitlab-ci.yml

@@ -1,17 +1,48 @@
 stages:
+  - test
   - build
 
-build-job:
-  stage: build
-  image: docker:latest
+.build_block: &build_block
+#  tags: [ build ]
+  image: docker:27.5.1-cli
   services:
-    - docker:dind
+    - name: docker:27.5.1-dind
+      alias: docker
   variables:
-    DOCKER_TLS_CERTDIR: "/certs"
-
-  before_script:
-    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    DOCKER_HOST: tcp://docker:2375
+    DOCKER_TLS_CERTDIR: ""
   script:
-    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA -t $CI_REGISTRY_IMAGE:latest -f docker/Dockerfile ./src
-    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
-    - docker push $CI_REGISTRY_IMAGE:latest
+    - export CI_COMMIT_TAG="${CI_COMMIT_TAG:-0.0.0}"
+    - |
+      if [ -n "${CI_REGISTRY:-}" ] && [ -n "${CI_REGISTRY_USER:-}" ] && [ -n "${CI_REGISTRY_PASSWORD:-}" ]; then
+        echo "${CI_REGISTRY_PASSWORD}" | docker login "${CI_REGISTRY}" -u "${CI_REGISTRY_USER}" --password-stdin
+      fi
+    - docker buildx create --name "${CI_PROJECT_NAME}-wrapper-builder" --driver docker-container --use || docker buildx use "${CI_PROJECT_NAME}-wrapper-builder"
+    - docker buildx inspect --bootstrap
+    - |
+      docker buildx build --load \
+        -t build/${CI_PROJECT_NAME} \
+        -f docker/Dockerfile.build \
+        --cache-from type=registry,ref=${CI_REGISTRY_IMAGE}/ci-wrapper:${CI_COMMIT_REF_SLUG}-cache \
+        --cache-to type=registry,ref=${CI_REGISTRY_IMAGE}/ci-wrapper:${CI_COMMIT_REF_SLUG}-cache,mode=max \
+        .
+    - docker run --rm `env | grep -o '^CI_[^=]*' | sed 's/^/-e /'`
+      -e REGISTRY_HOST=$CI_REGISTRY/$CI_PROJECT_NAMESPACE
+      -v /var/run/docker.sock:/var/run/docker.sock
+      -v /root/.docker:/root/.docker
+      build/${CI_PROJECT_NAME} 2>&1
+
+build push:
+  <<: *build_block
+  stage: build
+  needs: [ tests ]
+
+tests:
+  <<: *build_block
+  stage: test
+  variables:
+    DOCKER_HOST: tcp://docker:2375
+    DOCKER_TLS_CERTDIR: ""
+    CI_SKIP_PUSH: true
+    # build-labels sets target for each service in docker-compose.yml
+    CI_BUILD_TARGET: tests

data/lib/stack-service-base/project_template/gitlab/docker/Dockerfile.build

@@ -0,0 +1,36 @@
+FROM ruby:3.4.4-slim-bookworm AS base
+RUN apt-get update && apt-get install -y --no-install-recommends bash ca-certificates curl git tar \
+    && rm -rf /var/lib/apt/lists/*
+RUN gem install build-labels:0.0.79
+RUN BUILDX_VERSION=v0.20.1 COMPOSE_VERSION=v2.33.0 install-docker-static 27.5.1
+
+WORKDIR /build
+
+COPY .. .
+
+CMD ["bash", "-euo", "pipefail", "-c", "\
+    cd /build/docker; \
+    if [ -n \"${CI_REGISTRY:-}\" ] && [ -n \"${CI_REGISTRY_USER:-}\" ] && [ -n \"${CI_REGISTRY_PASSWORD:-}\" ]; then \
+      echo \"$CI_REGISTRY_PASSWORD\" | docker login \"$CI_REGISTRY\" -u \"$CI_REGISTRY_USER\" --password-stdin; \
+    fi; \
+    build-labels -n -c docker-compose.yml changed gitlab set_version cache to_dockerfiles to_compose | tee bake.yml; \
+    export OTEL_RESOURCE_ATTRIBUTES=\"service.name=docker-builder,pipeline.id=${CI_PIPELINE_ID:-local},project.name=${service_name}\"; \
+    export REGISTRY_HOST=\"${REGISTRY_HOST:-${CI_REGISTRY_HOST:-${CI_REGISTRY_IMAGE:-}}}\"; \
+    : \"${REGISTRY_HOST:?REGISTRY_HOST, CI_REGISTRY_IMAGE, or CI_REGISTRY_HOST is required}\"; \
+    export BUILDX_BAKE_ENTITLEMENTS_FS=0; \
+    if grep -q \"services: {}\" bake.yml; then \
+      echo \"No changed services to build.\"; \
+      exit 0; \
+    fi; \
+    docker buildx create --name \"${service_name}-builder\" --driver docker-container --use || docker buildx use \"${service_name}-builder\"; \
+    docker buildx inspect --bootstrap; \
+    if [ -n \"${CI_SKIP_PUSH:-}\" ]; then \
+      docker buildx bake --load --allow=fs.read=../src -f bake.yml; \
+    else \
+      docker buildx bake --push --allow=fs.read=../src -f bake.yml; \
+    fi; \
+    if [ \"${CI_BUILD_TARGET:-}\" = \"tests\" ]; then \
+      docker compose -f bake.yml down --remove-orphans; \
+      docker compose -f bake.yml up --no-build --force-recreate --abort-on-container-failure; \
+    fi \
+    "]

data/lib/stack-service-base/project_template/gitlab/docker/docker-compose.yml

@@ -1,6 +1,6 @@
 services:
   ${service_name}:
-    image: ${REGISTRY_HOST}/${service_name}
+    image: ${REGISTRY_HOST}/${service_name}/${CI_COMMIT_REF_SLUG:-local}
     build:
       context: ../src
       additional_contexts:

data/lib/stack-service-base/project_template/gitlab/docker/local_build.sh

@@ -0,0 +1,10 @@
+export CI_PROJECT_NAME=${service_name}
+export CI_PIPELINE_ID=local
+export CI_PIPELINE_IID=0
+export CI_REGISTRY_HOST=localhost
+export CI_SKIP_PUSH=true
+
+#  -v /root/.docker:/root/.docker \
+docker run --rm --env-file <(env | grep ^CI_) \
+  -v /var/run/docker.sock:/var/run/docker.sock \
+  $(docker build -q -t build/${CI_PROJECT_NAME} -f Dockerfile.build ..) 2>&1

data/lib/stack-service-base/stack_template/gitlab-c/.gitlab-ci.yml

@@ -1,3 +1,4 @@
+# Long ....
 stages:
   - deploy
 

data/lib/stack-service-base/version.rb

@@ -1,3 +1,3 @@
 module StackServiceBase
-  VERSION = '0.0.97'
+  VERSION = '0.0.99'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stack-service-base
 version: !ruby/object:Gem::Version
-  version: 0.0.97
+  version: 0.0.99
 platform: ruby
 authors:
 - Artyom B
@@ -433,7 +433,9 @@ files:
 - lib/stack-service-base/project_template/gitlab-c/docker/docker-compose.yml
 - lib/stack-service-base/project_template/gitlab-c/docker/local_build.sh
 - lib/stack-service-base/project_template/gitlab/.gitlab-ci.yml
+- lib/stack-service-base/project_template/gitlab/docker/Dockerfile.build
 - lib/stack-service-base/project_template/gitlab/docker/docker-compose.yml
+- lib/stack-service-base/project_template/gitlab/docker/local_build.sh
 - lib/stack-service-base/project_template/home/.gitignore
 - lib/stack-service-base/project_template/home/AGENTS.md
 - lib/stack-service-base/project_template/home/docker/.env