brut 0.5.0 → 0.8.0

data/mkbrut/templates/Base/bin/startup-message

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "yaml"
+require "optparse"
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: bin/startup-message\n\n    Outputs a message about where the dev server is running\n\nENVIRONMENT VARIABLES\n\n    PORT - the port configured for bin/run"
+end
+option_parser.parse!
+
+docker_compose_file = Pathname.new(__FILE__).dirname / ".." / "docker-compose.dx.yml"
+
+port_config = nil
+error       = nil
+
+if docker_compose_file.exist?
+  docker_compose = YAML.load_file(docker_compose_file)
+
+  docker_port = begin
+                  ENV.fetch("PORT")
+                rescue KeyError
+                  $stderr.puts "ERROR: The PORT environment variable is not set."
+                  $stderr.puts "       Please set it to the port your app is running on."
+                  exit 1
+                end
+
+  ports_config = docker_compose.dig("services", "app", "ports")
+  error = nil
+  if ports_config
+    port_config = ports_config.detect { |port_mapping|
+      host_port, container_port = port_mapping.split(":")
+      container_port.to_s == docker_port
+    }
+    if !port_config
+      error = "#{docker_compose_file} does not expose the port #{docker_port} for the 'app' service."
+    end
+  else
+    error = "#{docker_compose_file} does not contain a 'ports' section for the 'app' service."
+  end
+else
+  error = "#{docker_compose_file} does not exist. This is assumed to be in placefor your dev environment"
+end
+if !error
+  sleep 2 # allow all other initial output from bin/dev to happen first
+
+  host_port = port_config.split(":")[0]
+
+  url = "http://localhost:#{host_port}"
+
+  $stdout.puts "Your app is now running at"
+  $stdout.puts
+  $stdout.puts "  #{url}"
+  $stdout.puts
+  $stdout.flush # ensure this output happens immediately
+else
+  $stderr.puts "WARN: #{$0} could not figure out what port the app is exposed on"
+  $stderr.puts
+  $stderr.puts "      #{error}"
+  $stderr.puts
+  $stderr.puts "      This won't stop your app from running, but it does mean"
+  $stderr.puts "      there is some issue with your dev environment"
+  $stderr.flush # ensure this error output happens immediately
+end
+sleep

data/mkbrut/templates/Base/bin/test

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+Bundler.require
+require "pathname"
+
+require "brut/cli/apps/test"
+exit Brut::CLI.app(Brut::CLI::Apps::Test,project_root: Pathname($0).dirname / "..")
+

data/mkbrut/templates/Base/bin/test-server

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -e 
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+ROOT_DIR="${SCRIPT_DIR}/.."
+
+usage() {
+  echo "Usage: $0"
+  echo
+  echo "    Run the app in the test environment, suitable for end-to-end tests"
+  echo "    This will build all assets first, but not rebuild or reload after that"
+  echo
+}
+
+for arg in "$@"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done
+
+RACK_ENV="test"
+export RACK_ENV
+echo "[ bin/test-server ] Building assets"
+"${SCRIPT_DIR}"/build-assets
+
+echo "[ bin/test-server ] Starting server"
+PORT=6503 bin/run &
+wait

data/mkbrut/templates/Base/bin/watch-and-build-assets

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# This script exists to ensure that chokidar actually terminates when foreman stops all the processes.
+# For whatever reason, if Procfile has the npx chokidar… invocation below, these processes are not
+# stopped.  Putting them into this script addresses that. Cool.
+
+set -e
+
+if [ -z "${1}" ] ; then
+  echo "[ $0 ] error: asset type required. Must be css, js, or images"
+  exit 65
+fi
+usage() {
+  echo "usage: $0 asset_type"
+  echo
+  echo "  Sets up a watching/rebuild command for the given asset. Useful in dev only"
+  echo
+  echo "  asset_types:"
+  echo
+  echo "    - css"
+  echo "    - js"
+  echo "    - images"
+  echo
+}
+for arg in "${@}"; do
+  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
+    usage
+    exit 0
+  fi
+done
+
+asset_type=$1
+watch_dir="app/src/front_end/${asset_type}/**/*"
+build_command="bin/build-assets ${asset_type}"
+
+export SHELL # chokidar needs this for reasons unknown to me
+exec npx chokidar --initial --polling --command "${build_command}" "${watch_dir}"

data/mkbrut/templates/Base/config.ru

@@ -0,0 +1,16 @@
+require_relative "app/bootstrap"
+bootstrap = Bootstrap.new.bootstrap!
+
+app = Rack::Builder.app do
+  use Rack::Session::Cookie,
+    key: "rack.session",
+    path: "/",
+    expire_after: 31_536_000,
+    same_site: :lax, # this allows links from other domains to send our cookies to us,
+                     # but only if such links are direct/obvious to the user.
+    secret: ENV.fetch("SESSION_SECRET")
+
+  run bootstrap.rack_app
+end
+run app
+

data/mkbrut/templates/Base/docker-compose.dx.yml

@@ -0,0 +1,92 @@
+# This file is heavily documented to explain what is going on and why.
+# If you are reading this, however, you now own this file and can
+# change it how you like. Just be sure you understand how it works in the
+# context of Dockerfile.dx and the files in dx/,
+# which are referred to as the Workspace
+#
+# This file is used to run several Docker containers, based on images, together
+# in a shared private network.  All containers run by this file will be able to see
+# each other over a network, but the only access your host (computer) will have to
+# these services is via explicitly exposed ports.
+
+services:
+  # 'app' is the service where all your dev tools will run. The tests will
+  # run in here as will the dev server.
+  #
+  # You interact with this container via `dx/exec`
+  app:
+    # IMAGE is defined in dx/docker-compose.env and is the name of an image
+    # built LOCALLY (never pushed to DockerHub) that has all the tools needed
+    # for developing your app installed into it.
+    image: ${IMAGE}
+    # This is magic that makes the Docker container stop much more quickly when
+    # you hit Ctrl-C.
+    init: true
+    # There are two types of volumes (drives) mounted.
+    volumes:
+      # This volume is your source code. Its source and target are the same
+      # so that stuff like language servers can work.
+      - type: bind
+        source: ${PWD}
+        target: ${PWD}
+        consistency: "consistent"
+      # This allows docker build commands run inside Docker, referred to
+      # as "docker out of docker". Essentially, Docker binaries installed into
+      # this container will access your host (you computer)'s Docker install.
+      # This is to allow it to build the production images.
+      - type: bind
+        source: "/var/run/docker.sock"
+        target: "/var/run/docker.sock"
+    # This is what is started up when you run `dx/start`. It just
+    # waits forever keeping the container running.
+    command: /home/appuser/show-help-in-app-container-then-wait.sh
+    # The working directory for any command, this is the same as your
+    # project root.
+    working_dir: ${PWD}
+    # This sets environment variables
+    environment:
+      # Because we'll install RubyGems inside our project (mostly to allow
+      # language servers to work), configuration in bash_customizations relies
+      # on this value being set
+      PROJECT_ROOT: ${PWD}
+    # This exposes ports from this running container to your localhost.
+    # In this case, we expose 6502, where the app runs, and 6503, where
+    # the test server runs.
+    #
+    # To change this, the port before the colon is where the app
+    # will be available on your localhost. The port AFTER the colon is where
+    # the app runs in the container.  So: change the port before the colon, and
+    # don't change the one after.
+    #
+    # * 6502 - dev
+    # * 6503 - test server (run by E2E tests)
+    ports:
+      - "6502:6502"
+      - "6503:6503"
+  # This "service" runs Postgres.  The service name ("postgres") is the host
+  # on which the service is available to other containers, namely from the 
+  # app container. You cannot connect to thise service from your host (computer)
+  # directly without additional configuration.
+  postgres:
+    # This image is the name of the image from DockerHub that will be pulled
+    # down to run Postgres.
+    image: postgres:16.4
+    pull_policy: "missing"
+    environment:
+      # Postgres will not work without being told the password. The most
+      # direct way to do that is via this environment variable.
+      POSTGRES_PASSWORD: postgres
+  # This runes otel-deskop-viewer, which will receive OpenTelemetry traces
+  # from your app. You can connect to this to observe those traces.
+  otel-desktop-viewer:
+    # The otel-desktop-viewer maintainers do not maintain a Docker
+    # image of the app. I have made one available on my DockerHub account.
+    # If you want to build your own, see 
+    # https://github.com/CtrlSpice/otel-desktop-viewer?tab=readme-ov-file#via-docker
+    # When you build that image, change the value for image: below to the image
+    # name you chose.
+    image: davetron5000/otel-desktop-viewer:alpine-3
+    # This runs internally on port 8000 but will be available
+    # on port 6504 of your machine.
+    ports:
+      - "6504:8000"

data/mkbrut/templates/Base/dx/README.md

@@ -0,0 +1,28 @@
+# Workspace Commands
+
+These commands manage the Workspace, AKA the part of the development environment that
+runs on your computer (sometimes called the *host*).
+
+These are all written in Bash as that is the only environment that can be relied upon to exist on any operating system.
+
+These are designed to be somewhat agnostic of your app and Brut may update some of
+these files if changes are needed.  All app-specific configuration is consolidated
+into just a few files.
+
+These files are owned by Brut and you should avoid editing them:
+
+* `bash_customizations` - Bash configuration
+* `build` - Builds the development docker image
+* `dx.sh.lib` - Shared bash functions
+* `exec` -  Run commands inside a container
+* `prune` - Remove unused containers
+* `README.md` - This file
+* `show-help-in-app-container-then-wait.sh` - Runs inside the app container to keep
+the container up
+* `start` - starts the Workspace/dev environment
+* `stop` - stops the Workspace/dev environment
+
+These files contain project-specific information and Brut will not change them:
+
+* `docker-compose.env` - Configuration values.
+* `bash_customizations.local` - Per-developer bash configuration, **project specific**, **developer specific**, **do not check into version control**.

data/mkbrut/templates/Base/dx/bash_customizations

@@ -0,0 +1,12 @@
+# This sets up RubyGems and Bundler so they install
+# all gems inside this project's root and not into the system
+# location.  This allows LSP servers to work more easily.
+if [ ! -n "$PROJECT_ROOT" ]; then
+  echo "[ bash_customizations ] WARNING: PROJECT_ROOT is not set - this will break RubyGems"
+fi
+export GEM_HOME=${PROJECT_ROOT}/local-gems/gem-home
+export PATH=${PATH}:${GEM_HOME}/bin
+# This sets up the Node version so we don't have to do it before every. single.
+# shell. invocation.
+. ~/.nvm/nvm.sh
+nvm use default

data/mkbrut/templates/Base/dx/bash_customizations.local

@@ -0,0 +1,8 @@
+# Insert developer-specifilc Bash customizations here.
+# This file is not checked into version control, so you
+# are safe to export EDITOR=vim and avoid any guff from 
+# co-workers.
+
+# Sets up a multi-line prompt since the working directory
+# may be very deep.  Customize or change at your leisure.
+PS1='\[\e[35m\]docker-container\[\e[0m\] - \[\e[37m\]\w\n\[\e[0m\]> '

data/mkbrut/templates/Base/dx/build

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+
+. "${SCRIPT_DIR}/dx.sh.lib"
+
+read_custom_build_args() {
+  build_args_file="${SCRIPT_DIR}/build.args"
+  if [ -e "${build_args_file}" ]; then
+    for arg in `grep -v '^#' "${build_args_file}"`; do
+      BUILD_ARGS+=(--build-arg ${arg})
+    done
+  fi
+}
+
+setup_local_user_build_args() {
+  require_command "id"
+  require_command "uname"
+  user_uid=$(id -u)
+  user_gid=$(id -g)
+  docker_gid=
+  sadly_user_must_be_added_to_root=
+  OS=$(uname)
+  if [ "${OS}" == "Darwin" ] ; then
+    docker_gid=$(stat -f %g /var/run/docker.sock)
+    sadly_user_must_be_added_to_root="0,"
+  else
+    if [ "${OS}" == "Linux" ] ; then
+      docker_gid=$(stat -c %g /var/run/docker.sock)
+    else
+      log "Could not determine OS, which is needed to know how to invoke stat to figure out the group id of /var/run/docker.sock"
+      log "Docker commands will not work"
+    fi
+  fi
+  echo user_uid=${user_uid}                                                 >> "${SCRIPT_DIR}"/build.args
+  echo user_gid=${user_gid}                                                 >> "${SCRIPT_DIR}"/build.args
+  echo docker_gid=${docker_gid}                                             >> "${SCRIPT_DIR}"/build.args
+  echo sadly_user_must_be_added_to_root=${sadly_user_must_be_added_to_root} >> "${SCRIPT_DIR}"/build.args
+}
+
+initialize_build_args() {
+  echo "# This is generated - see build.pre" > "${SCRIPT_DIR}"/build.args
+}
+
+setup_playright_build_args() {
+  require_command "grep"
+  require_command "sed"
+
+  if [ ! -e "${SCRIPT_DIR}"/Gemfile.lock ]; then
+    log "Could not find Gemfile.lock, which is needed to determine the playwright-ruby-client version"
+    log "Assuming your app is brand-new, this should be OK"
+    echo "# When this file was created, there was no Gemfile.lock, so"               >> "${SCRIPT_DIR}"/build.args
+    echo "# it was not possible to determine which version of Playright was set up." >> "${SCRIPT_DIR}"/build.args
+    echo "# Once you've build your app and installed gems, you are "                 >> "${SCRIPT_DIR}"/build.args
+    echo "# encouraged to re-run \`dx/build\` to address this issue."                >> "${SCRIPT_DIR}"/build.args
+    echo PLAYWRIGHT_VERSION=latest                                                   >> "${SCRIPT_DIR}"/build.args
+  else
+    PLAYWRIGHT_VERSION=$(grep playwright-ruby-client Gemfile.lock  | grep '(' | sed 's/^.*(//' | sed 's/).*$//' | grep -v ^=)
+    if [ -z "${PLAYWRIGHT_VERSION}" ]; then
+      log "Could not find precise version of playwright-ruby-client from Gemfile.lock"
+      log "This means that your playwright-ruby-client version and playwright NPM modules may be out of sync and may not work"
+      echo "# When this file was created, Gemfile.lock did not"                    >> "${SCRIPT_DIR}"/build.args
+      echo "# contain playwrith-ruby-client.  This means it"                       >> "${SCRIPT_DIR}"/build.args
+      echo "# it was not possible to determine which version of"                   >> "${SCRIPT_DIR}"/build.args
+      echo "# Playright was set up. If you aren't using Playwright,"               >> "${SCRIPT_DIR}"/build.args
+      echo "# that's fine, this won't cause issues"                                >> "${SCRIPT_DIR}"/build.args
+      echo "# If you ARE using Playwright, something may be wrong with your setup" >> "${SCRIPT_DIR}"/build.args
+      echo PLAYWRIGHT_VERSION=latest                                               >> "${SCRIPT_DIR}"/build.args
+    else
+      echo PLAYWRIGHT_VERSION=${PLAYWRIGHT_VERSION} >> "${SCRIPT_DIR}"/build.args
+    fi
+  fi
+}
+
+require_command "docker"
+load_docker_compose_env
+
+usage_on_help "Builds the Docker image based on the Dockerfile" "" "build.pre" "build.post" "${@}"
+
+if ! exec_hook_if_exists "build.pre" Dockerfile.dx "${IMAGE}"; then
+  log "build.pre failed"
+  exit 1
+fi
+BUILD_ARGS=()
+
+initialize_build_args
+setup_local_user_build_args
+setup_playright_build_args
+read_custom_build_args
+
+docker build \
+  --file Dockerfile.dx \
+  --tag "${IMAGE}" \
+  ${BUILD_ARGS[@]} \
+  ./
+
+if ! exec_hook_if_exists "build.post" Dockerfile.dx "${IMAGE}"; then
+  log "build.pre failed"
+  exit 1
+fi
+
+log "🌈" "Your Docker image has been built tagged '${IMAGE}'"
+log "🔄" "You can now run dx/start to start it up, though you may need to stop it first with Ctrl-C"
+
+# vim: ft=bash

data/mkbrut/templates/Base/dx/docker-compose.env.erb

@@ -0,0 +1,25 @@
+# This file is an input to Docker Compose, and serves
+# as an additional set of environment variables.
+
+# IMAGE is the name of the image to be built for running
+# your app. The recommended format is ORG/REPO:TAG
+#
+# The ORG and REPO are based on the values used
+# with mkbrut.  TAG is set to mimic the value
+# in the FROM directive of the Dockerfile.
+# This will allow you to upgrade Ruby and run both
+# versions more easily.
+IMAGE=<%= organization %>/<%= app_name %>:ruby-3.4
+
+# PROJECT_NAME is used when running Docker compose
+# to help ensure the output includes your project's name.
+PROJECT_NAME=<%= app_name %>
+
+# DEFAULT_SERVICE is the name of the service (keys under 
+# service: in docker-compose.dx.yml) to use when
+# running dx/exec and no service is specified. 
+# The value "app" should match that in docker-compose.dx.yml
+# having the effect of dx/exec running commands inside your app's
+# container.
+DEFAULT_SERVICE=app
+# vim: ft=bash

data/mkbrut/templates/Base/dx/dx.sh.lib

@@ -0,0 +1,137 @@
+# shellcheck shell=bash
+
+# These are various functions needed by all the other scripts in dx/
+
+# Log a fatal error and exit nonzero
+fatal() {
+  remainder=${*:2}
+  if [ -z "$remainder" ]; then
+    log "🛑" "${@}"
+  else
+    log "${@}"
+  fi
+  exit 1
+}
+
+# Log an informational message. This is preferable to simply
+# using `echo` because it prepends the message with the name
+# of the script so you can tell where the message came from. 
+log() {
+  emoji=$1
+  remainder=${*:2}
+  if [ -z "${NO_EMOJI}" ]; then
+    echo "[ ${0} ] ${*}"
+  else
+    # if remainder is empty that means no emoji was passed
+    if [ -z "$remainder" ]; then
+      echo "[ ${0} ] ${*}"
+    else # emoji was passed, but we ignore it
+      echo "[ ${0} ] ${remainder}"
+    fi
+  fi
+}
+
+# Output a debug message if BRUT_WORKSPACE_DEBUG is set
+debug() {
+  message=$1
+  if [ -z "${BRUT_WORKSPACE_DEBUG}" ]; then
+    return
+  fi
+  log "🐛" "${message}"
+}
+
+# Output general usage information for the command and exit zero.
+#
+# Args:
+#
+# [1] the description of the command
+# [2] The names of the arguments
+# [3] If given, the name of the pre hook that the command responds to
+# [4] If given, the name of the post hook that the command responds to
+usage() {
+  description=$1
+  arg_names=$2
+  pre_hook=$3
+  post_hook=$4
+  echo "usage: ${0} [-h] ${arg_names}"
+  if [ -n "${description}" ]; then
+    echo
+    echo "DESCRIPTION"
+    echo "    ${description}"
+  fi
+  if [ -n "${pre_hook}" ] || [ -n "${post_hook}" ]; then
+    echo
+    echo "HOOKS"
+    if [ -n "${pre_hook}" ]; then
+      echo "    ${pre_hook} - if present, called before the main action"
+    fi
+    if [ -n "${post_hook}" ]; then
+      echo "    ${post_hook} - if present, called after the main action"
+    fi
+  fi
+  exit 0
+}
+
+# Show usage if the command line invocation indicated that help was requested.
+# This calls usage, so this will exit 0
+#
+# Args:
+#
+# [1] the description of the command
+# [2] The names of the arguments
+# [3] If given, the name of the pre hook that the command responds to
+# [4] If given, the name of the post hook that the command responds to
+usage_on_help() {
+  description=$1
+  arg_names=$2
+  pre_hook=$3
+  post_hook=$4
+  # These are the args passed to the invocation so this
+  # function can determine if the user requested help
+  cli_args=( "${@:5}" ) 
+
+  for arg in "${cli_args[@]}"; do
+    if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ]; then
+      usage "${description}" "${arg_names}" "${pre_hook}" "${post_hook}"
+    fi
+  done
+}
+
+# Ensure that a command line utility exists, exiting nonzero if not.
+# This is needed to avoid assumptions about what commands a user may have
+# on their computer. It attempts to provide a more useful error message
+# than "command not found".
+require_command() {
+  command_name=$1
+  if ! command -v "${command_name}" >/dev/null 2>&1; then
+    fatal "Command '${command_name}' not found - it is required for this script to run"
+  fi
+}
+
+# This loads dx/docker-compose.env as variables to the bash script, thus
+# allowing Docker Compose and these scripts to share configuration.
+load_docker_compose_env() {
+  . "${ENV_FILE}"
+}
+
+# Execute a hook if the file exists.  Note that if the hook exits
+# nonzero, the caller will need to check the return value of this function and decide
+# what to do.
+exec_hook_if_exists() {
+  script_name=$1
+  shift
+  if [ -x "${SCRIPT_DIR}"/"${script_name}" ]; then
+    log "🪝" "${script_name} exists - executing"
+    "${SCRIPT_DIR}"/"${script_name}" "${@}"
+  else
+    debug "${script_name} does not exist"
+  fi
+}
+
+require_command "realpath"
+require_command "cat"
+
+# Set up the location to the docker-compose.env file.
+ENV_FILE=$(realpath "${SCRIPT_DIR}")/docker-compose.env
+
+# vim: ft=bash

data/mkbrut/templates/Base/dx/exec

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+
+. "${SCRIPT_DIR}/dx.sh.lib"
+
+require_command "docker"
+load_docker_compose_env
+
+usage_description="Execute a command inside the app's container. Any command other than 'bash' will be run with bash -lc. Use -B to just run the command directly."
+usage_args="[-s service] [-B] command"
+usage_pre="exec.pre"
+usage_on_help "${usage_description}" "${usage_args}" "${usage_pre}" "" "${@}"
+
+SERVICE="${SERVICE_NAME:-${DEFAULT_SERVICE}}"
+INCLUDE_PREFIX_FOR_NON_BASH=true
+while getopts "s:B" opt "${@}"; do
+  case ${opt} in
+    s )
+      SERVICE="${OPTARG}"
+      ;;
+    B )
+      INCLUDE_PREFIX_FOR_NON_BASH=false
+      ;;
+    \? )
+      log "🛑" "Unknown option: ${opt}"
+      usage "${description}" "${usage_args}" "${usage_pre}"
+      ;;
+    : )
+      log "🛑" "Invalid option: ${opt} requires an argument"
+      usage "${description}" "${usage_args}" "${usage_pre}"
+      ;;
+  esac
+done
+shift $((OPTIND -1))
+
+if [ $# -eq 0 ]; then
+  log "🛑" "You must provide a command e.g. bash or ls -l"
+  usage "${description}" "${usage_args}" "${usage_pre}"
+fi
+
+if ! exec_hook_if_exists "exec.pre"; then
+  log "build.pre failed"
+  exit 1
+fi
+
+if [ "$#" -eq 1 ] && [ "$1" = "bash" ]; then
+  COMMAND=(bash)
+elif [ "$INCLUDE_PREFIX_FOR_NON_BASH" = "true" ]; then
+  COMMAND=(bash -lc "$*")
+else
+  COMMAND=("$@")
+fi
+
+log "🚂" "Running '${COMMAND[@]}' inside container with service name '${SERVICE}'"
+
+docker \
+  compose \
+    --file docker-compose.dx.yaml \
+    --project-name "${PROJECT_NAME}" \
+    --env-file "${ENV_FILE}" \
+  exec \
+    "${SERVICE}" \
+    "${COMMAND[@]}"
+
+# vim: ft=bash

data/mkbrut/templates/Base/dx/prune

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
+
+. "${SCRIPT_DIR}/dx.sh.lib"
+require_command "docker"
+load_docker_compose_env
+
+usage_on_help "Prune containers for this repo" "" "" "" "${@}"
+
+for container_id in $(docker container ls -a -f "name=^${PROJECT_NAME}-.*-1$" --format="{{.ID}}"); do
+  log "🗑" "Removing container with id '${container_id}'"
+  docker container rm "${container_id}"
+done
+echo "🧼" "Containers removed"
+
+# vim: ft=bash