belt-connect 0.2.0

data/lib/belt/generators/connect/add_widget.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'belt/connect'
+
+module Belt
+  module Generators
+    # `belt generate connect add-widget <name> [snippet-file] [--env <env>]`
+    #
+    # Parses an Amazon Connect "Get widget code" snippet and upserts a named
+    # entry into the frontend widget registry (frontend/src/connect/widgets.js),
+    # then prints the VITE_CONNECT_<NAME>_* env lines to add. The base64
+    # snippetId is a secret, so it is wired through env — never written into the
+    # committed registry — while the widget id and URL (not secret) land in the
+    # registry as readable config.
+    #
+    # Convention: the raw snippet lives at config/connect/widgets/<name>.js in
+    # the app (gitignored — it holds the snippetId). Omit the file argument and
+    # that's where we look; pass a file from anywhere else and it's copied there
+    # so the app always has one obvious bay for widget sources instead of a
+    # paste in a ticket.
+    #
+    # With --env <env>, the three SSM parameters the Terraform module seeds
+    # (chat-snippet-id, chat-widget-url, chat-widget-element-id) are written as
+    # a matched set from the same parsed snippet, so a human never runs three
+    # `aws ssm put-parameter` commands by hand and mixes widgets (the 403).
+    #
+    # This is the mechanical snippet->config translation that stops a human from
+    # ever retyping the base64 snippetId (the bug behind the wrong-widget 403).
+    class ConnectGenerator
+      class AddWidget
+        WIDGETS_DIR = 'config/connect/widgets'
+
+        # SSM parameter names the Terraform module provisions, keyed by the
+        # parsed-snippet field that feeds each one. Matched set — same widget.
+        SSM_PARAMS = {
+          snippet_id: 'chat-snippet-id',
+          widget_url: 'chat-widget-url',
+          id: 'chat-widget-element-id'
+        }.freeze
+
+        # runner: how shell commands are executed (swapped out in specs).
+        def initialize(args, runner: method(:system))
+          @runner = runner
+          @opts   = parse_options(args)
+          @name   = @opts[:positional][0]
+          @source = @opts[:positional][1]
+        end
+
+        def run
+          return usage if @name.nil? || @opts[:help]
+
+          snippet = read_snippet
+          return if snippet.nil?
+
+          result = Belt::Connect::SnippetParser.parse(snippet)
+
+          registry = registry_path
+          unless File.exist?(registry)
+            warn "Widget registry not found at #{registry}."
+            warn 'Run `belt generate connect` first to scaffold it.'
+            return
+          end
+
+          stash_snippet(snippet)
+          upsert_entry(registry, @name, result)
+          warn_jwt if result.jwt?
+          push_ssm(result) if @opts[:env] || @opts[:ssm_prefix]
+          print_result(@name, result)
+        rescue Belt::Connect::SnippetParser::ParseError => e
+          warn "Could not parse the Connect snippet: #{e.message}"
+          warn 'Make sure you copied the full "Get widget code" <script> block.'
+        end
+
+        private
+
+        def parse_options(args)
+          opts = { positional: [] }
+          rest = args.dup
+          until rest.empty?
+            arg = rest.shift
+            case arg
+            when '--env'        then opts[:env] = rest.shift
+            when '--app-name'   then opts[:app_name] = rest.shift
+            when '--ssm-prefix' then opts[:ssm_prefix] = rest.shift
+            when '--help', '-h' then opts[:help] = true
+            when /\A--/
+              warn "Unknown option #{arg} (ignored)"
+            else
+              opts[:positional] << arg
+            end
+          end
+          opts
+        end
+
+        def usage
+          puts <<~USAGE
+            Usage: belt generate connect add-widget <name> [snippet-file] [options]
+
+            Parses an Amazon Connect "Get widget code" snippet into the widget
+            registry and prints the env lines to add.
+
+            The snippet is read from #{WIDGETS_DIR}/<name>.js when no file is
+            given. A file passed from anywhere else is copied there, so the app
+            always has one place for widget sources (the directory is gitignored —
+            the snippet holds the secret snippetId).
+
+            Options:
+              --env <env>           Also write the matched set (snippet id, widget
+                                    url, element id) to the module's SSM params:
+                                    /<app-name>/<env>/connect/chat-*
+              --app-name <name>     App name for the SSM prefix (default: detected
+                                    from config/routes.rb, else the directory name)
+              --ssm-prefix <path>   Full SSM prefix, overrides --env/--app-name
+              -h, --help            Show this help
+
+            Examples:
+              belt generate connect add-widget support
+              belt generate connect add-widget support ~/Downloads/code.js --env sandbox
+          USAGE
+        end
+
+        # --- snippet source -------------------------------------------------
+
+        def conventional_path
+          File.join(WIDGETS_DIR, "#{@name}.js")
+        end
+
+        def read_snippet
+          if @source.nil?
+            return File.read(conventional_path) if File.exist?(conventional_path)
+
+            warn "No snippet file given and #{conventional_path} does not exist."
+            warn ''
+            warn 'Create the widget in the Connect admin console (Channels → Communications'
+            warn "widgets → Copy script), save the <script> block to #{conventional_path},"
+            warn 'then re-run. Or pass the file path explicitly.'
+            return nil
+          end
+
+          return File.read(@source) if File.exist?(@source)
+
+          # Allow passing the snippet inline as well (handy for scripts/pipes).
+          @source
+        end
+
+        # Keep the raw snippet at the conventional path so the next person (or
+        # machine) can re-run add-widget without hunting for a paste.
+        def stash_snippet(snippet)
+          return if @source.nil? # already read from the conventional path
+          return if File.exist?(@source) && File.expand_path(@source) == File.expand_path(conventional_path)
+
+          FileUtils.mkdir_p(WIDGETS_DIR)
+          File.write(conventional_path, snippet)
+          puts "  stash   #{conventional_path} (gitignored — holds the snippetId)"
+        end
+
+        # --- registry -------------------------------------------------------
+
+        def registry_path
+          base = if Dir.exist?('app/src') && !Dir.exist?('frontend/src')
+                   'app/src/connect'
+                 else
+                   'frontend/src/connect'
+                 end
+          File.join(base, 'widgets.js')
+        end
+
+        # Build the JS entry for a widget. id + widgetUrl are readable config and
+        # go straight into the registry; snippetId stays an env reference.
+        def entry_js(name, result)
+          <<~JS.chomp
+            #{name}: {
+                // Widget instance id (4th arg of the Connect bootstrap snippet).
+                id: "#{result.id}",
+                // Secret — stays in env/SSM, never committed.
+                snippetId: import.meta.env.#{env_var(name, 'SNIPPET_ID')},
+                // Hosted widget loader URL (same per Connect instance).
+                widgetUrl: "#{result.widget_url}",
+                styles: {
+                  iconType: "#{icon_type(result)}",
+                  brandColor: BRAND_COLOR,
+                  typeface: TYPEFACE,
+                },
+              }
+          JS
+        end
+
+        def icon_type(result)
+          (result.styles && result.styles['iconType']) || 'CHAT'
+        end
+
+        def env_var(name, suffix)
+          "VITE_CONNECT_#{name.upcase}_#{suffix}"
+        end
+
+        # Upsert the named entry inside the `export const widgets = { ... }`
+        # object. If the name already exists, replace its block; otherwise insert
+        # a new one right after the opening brace.
+        def upsert_entry(path, name, result)
+          source = File.read(path)
+          entry  = "  #{entry_js(name, result)},"
+
+          source =
+            if source =~ /export const widgets = \{/ && source.match?(existing_within_widgets(name))
+              replace_entry(source, name, entry)
+            else
+              source.sub(/export const widgets = \{\n/, "export const widgets = {\n#{entry}\n")
+            end
+
+          File.write(path, source)
+          puts "  update  #{path} (widget \"#{name}\")"
+        end
+
+        # A loose matcher used only to decide replace-vs-insert.
+        def existing_within_widgets(name)
+          /^\s{2}#{Regexp.escape(name)}:\s*\{/m
+        end
+
+        def replace_entry(source, name, entry)
+          # Replace a top-level (2-space indented) named block, brace-balanced.
+          source.sub(/^\s{2}#{Regexp.escape(name)}:\s*\{.*?\n\s{2}\},?\n/m, "#{entry}\n")
+        end
+
+        # --- JWT --------------------------------------------------------------
+
+        def warn_jwt
+          warn ''
+          warn '⚠ This snippet has JWT security enabled (it contains an'
+          warn "  amazon_connect('authenticate', ...) hook). belt-connect's loader does"
+          warn '  not implement that callback yet, so the widget will load but refuse to'
+          warn '  start a chat. Either recreate the widget with security skipped'
+          warn '  ("No - I do not want to enable JWT security measures"), or add a'
+          warn '  backend route that signs a JWT with the widget security key and wire'
+          warn "  it into ConnectWidget.jsx via amazon_connect('authenticate', cb)."
+        end
+
+        # --- SSM --------------------------------------------------------------
+
+        def ssm_prefix
+          return @opts[:ssm_prefix].sub(%r{/\z}, '') if @opts[:ssm_prefix]
+
+          "/#{@opts[:app_name] || detect_app_name}/#{@opts[:env]}/connect"
+        end
+
+        # Same detection the main generator uses for the module's app_name
+        # default, so the prefix lines up with what Terraform created.
+        def detect_app_name
+          ['config/routes.tf.rb', 'infrastructure/routes.tf.rb', 'config/routes.rb'].each do |path|
+            next unless File.exist?(path)
+
+            match = File.read(path).match(/namespace :(\w+)/)
+            return match[1] if match
+          end
+          File.basename(Dir.pwd)
+        end
+
+        def push_ssm(result)
+          prefix = ssm_prefix
+          puts ''
+          puts "Writing the matched set to SSM under #{prefix}/ (type String, --overwrite):"
+
+          failed = SSM_PARAMS.reject do |field, param|
+            name = "#{prefix}/#{param}"
+            ok = @runner.call('aws', 'ssm', 'put-parameter', '--overwrite', '--type', 'String',
+                              '--name', name, '--value', result.public_send(field).to_s,
+                              out: File::NULL)
+            puts "  #{ok ? 'put' : 'FAIL'}     #{name}"
+            ok
+          end
+
+          if failed.empty?
+            env = @opts[:env] || '<env>'
+            puts '  ✓ SSM matched set written.'
+            puts ''
+            puts 'The module reads these back through SSM data sources, which only refresh'
+            puts 'on apply — so the Terraform outputs (and therefore the frontend build)'
+            puts 'still see the old value until you refresh state:'
+            puts ''
+            puts "  terraform -chdir=infrastructure/#{env} apply -refresh-only -auto-approve"
+            puts "  belt deploy frontend #{env}"
+          else
+            warn ''
+            warn 'Some SSM writes failed (is AWS_PROFILE set and `aws` on PATH?). Run by hand:'
+            failed.each do |field, param|
+              warn "  aws ssm put-parameter --overwrite --type String --name #{prefix}/#{param} --value '#{result.public_send(field)}'"
+            end
+          end
+        end
+
+        # --- output -----------------------------------------------------------
+
+        def print_result(name, result)
+          puts ''
+          puts "✓ Widget \"#{name}\" written to the registry."
+          puts ''
+          if @opts[:env] || @opts[:ssm_prefix]
+            puts "The snippetId is in SSM; frontend/env.yml maps #{env_var(name, 'SNIPPET_ID')} to the"
+            puts 'Terraform output so `belt deploy frontend <env>` injects it at build time.'
+            puts 'For local dev, `belt frontend env <env>` merges it into frontend/.env.'
+          else
+            puts 'Add this to your frontend .env (the snippetId is a secret — keep it out of git):'
+            puts ''
+            puts "  #{env_var(name, 'SNIPPET_ID')}=#{result.snippet_id}"
+            puts ''
+            puts 'Or pass --env <env> to write it (and the widget url + element id) to SSM'
+            puts 'as a matched set so the build injects it from the Terraform output.'
+          end
+          puts ''
+          puts 'Then mount it:'
+          puts ''
+          puts "  import ConnectWidget, { openConnectChat } from './connect/ConnectWidget'"
+          puts "  <ConnectWidget name=\"#{name}\" />"
+          puts "  <button onClick={() => openConnectChat('#{name}')}>Chat with us</button>"
+        end
+      end
+    end
+  end
+end

data/lib/belt/generators/connect_generator.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require 'belt/connect'
+require_relative 'connect/add_widget'
+
+module Belt
+  module Generators
+    # Generator discovered automatically by Belt::CLI::GeneratorRegistry.
+    # File MUST live at: lib/belt/generators/connect_generator.rb
+    # Class MUST be:     Belt::Generators::ConnectGenerator
+    #
+    # Available as:
+    #   belt generate connect
+    #   belt destroy connect
+    #
+    # Scaffolds Amazon Connect (Connect Customer) into the host Belt app:
+    # - aws_connect_instance (SAML identity management, chat enabled)
+    # - Approved origins (null_resource + local-exec; no native TF resource)
+    # - 24/7 hours of operation
+    # - Chat contact flow with off-hours queuing, a queue, and a CHAT routing profile
+    # - SSM params for the hosted chat widget snippet/URL (ignore_changes)
+    # - SAML federation: IAM SAML provider + role for Identity Center SSO
+    # - A frontend widget loader (React) wired to the SSM/env values
+    #
+    # Extracted and generalized from Stowzilla's standalone connect-infrastructure:
+    # brand color, approved origins, and the SSM prefix are now app config, not
+    # hard-coded to Stowzilla.
+    class ConnectGenerator
+      TEMPLATE_DIR = File.expand_path('../connect/templates', __dir__)
+      MODULE_DIR   = 'infrastructure/modules/connect'
+
+      # Terraform templates emitted into the host app's module directory.
+      TERRAFORM_FILES = {
+        'terraform/main.tf.erb'      => 'main.tf',
+        'terraform/variables.tf.erb' => 'variables.tf',
+        'terraform/outputs.tf.erb'   => 'outputs.tf'
+      }.freeze
+
+      # Frontend assets emitted into the host app. The widget registry
+      # (widgets.js) is the source of truth for every widget; ConnectWidget.jsx
+      # is the single generic loader driven by a widget name. Both live under
+      # frontend/src/connect/ so the app has one obvious place for widget wiring.
+      FRONTEND_FILES = {
+        'frontend/widgets.js.erb'       => 'widgets.js',
+        'frontend/ConnectWidget.jsx.erb' => 'ConnectWidget.jsx'
+      }.freeze
+
+      # Where raw console snippets live in the host app (see AddWidget). The
+      # README is committed; the *.js snippets hold the secret snippetId and are
+      # gitignored by the lines below.
+      WIDGETS_DIR       = AddWidget::WIDGETS_DIR
+      WIDGETS_README    = 'config/widgets-README.md.erb'
+      GITIGNORE_LINES   = [
+        '# Amazon Connect widget snippets (belt-connect) — hold the secret snippetId',
+        "/#{WIDGETS_DIR}/*.js"
+      ].freeze
+
+      def self.description
+        'Install Amazon Connect: chat widget + call-center contact flow, queue, routing, and SAML SSO'
+      end
+
+      def self.run(args)
+        if args.include?('--help') || args.include?('-h')
+          print_help
+          return
+        end
+
+        # Subcommand: `belt generate connect add-widget <name> <snippet-file>`
+        # parses a pasted Connect console snippet into the widget registry so the
+        # base64 snippetId is never retyped by hand.
+        return AddWidget.new(args[1..] || []).run if args.first == 'add-widget'
+
+        new(args).generate
+      end
+
+      def self.destroy(args)
+        new(args).destroy
+      end
+
+      def self.print_help
+        puts <<~HELP
+          Install belt-connect into a Belt application.
+
+          Usage: belt generate connect [options]
+                 belt generate connect add-widget <name> [snippet-file] [--env <env>]
+
+          Options:
+            --skip-frontend       Only emit the Terraform module (no React widget)
+            --force               Overwrite existing files
+            -h, --help            Show this help
+
+          What gets created:
+            infrastructure/modules/connect/   Terraform module
+              - main.tf        Connect instance, approved origins, hours of
+                               operation, chat contact flow (off-hours queuing),
+                               queue, CHAT routing profile, SSM widget params,
+                               SAML federation (IAM provider + role)
+              - variables.tf   Inputs (app_name, environment, instance_alias,
+                               approved_origins, brand/SSM knobs, saml_metadata_file)
+              - outputs.tf     instance_id/arn, admin_console_url, contact_flow_id,
+                               queue_id, routing_profile_id, saml_* arns
+
+            frontend/src/connect/widgets.js            Widget registry — the single
+                               source of truth for every hosted widget (id, url,
+                               styles). snippetId is read from env (it's a secret).
+            frontend/src/connect/ConnectWidget.jsx     Generic hosted-chat loader
+                               driven by a widget name; exports openConnectChat(name)
+            config/connect/widgets/README.md           Drop zone for raw console
+                               snippets (<name>.js, gitignored — they hold the
+                               secret snippetId); .gitignore gets the entry
+
+          Adding a widget:
+            Create a hosted chat widget in the Connect admin console (answer "No"
+            to JWT security unless you implement the authenticate callback), save
+            its "Get widget code" snippet to config/connect/widgets/<name>.js, then:
+
+              belt generate connect add-widget support --env sandbox
+
+            This parses the snippet into widgets.js (so the base64 snippetId is
+            never retyped) and, with --env, writes the matched set (snippet id,
+            widget url, element id) to the module's SSM params so the build
+            injects it via frontend/env.yml. Without --env it prints the
+            VITE_CONNECT_<NAME>_SNIPPET_ID line for a local .env instead.
+
+          After generation:
+            1. Add the module to your environment main.tf:
+                 module "connect" {
+                   source           = "../modules/connect"
+                   app_name         = var.app_name
+                   environment      = var.environment
+                   aws_region       = var.aws_region
+                   instance_alias   = "${var.app_name}-${var.environment}"
+                   approved_origins = ["https://${var.environment}.example.com"]
+                   # Demo/sandbox: password logins instead of SAML, so someone can
+                   # actually sign in to the CCP and answer the chat.
+                   # identity_management_type = "CONNECT_MANAGED"
+                   # users = { "agent" = { security_profiles = ["Agent"] } }
+                 }
+            2. Deploy: belt deploy <env>
+            3. Create a hosted chat widget, then run `belt generate connect add-widget`.
+
+          Examples:
+            belt g connect
+            belt g connect --skip-frontend
+            belt g connect add-widget support --env sandbox
+            belt g connect add-widget support ~/Downloads/code.js --env sandbox
+            belt d connect
+        HELP
+      end
+
+      def initialize(args)
+        @force         = args.include?('--force')
+        @skip_frontend = args.include?('--skip-frontend')
+        # @app_name feeds the ERB-templated headers / defaults through the
+        # binding passed to #write_template. Detected the same way as
+        # belt-cost-monitoring / belt-messaging / belt-pay.
+        @app_name    = detect_namespace
+        @brand_color = Belt::Connect.configuration.brand_color
+        @typeface    = Belt::Connect.configuration.typeface
+      end
+
+      def generate
+        puts "Installing Amazon Connect into #{MODULE_DIR}/"
+        puts ''
+
+        generate_terraform_module
+        generate_frontend unless @skip_frontend
+        print_success
+      end
+
+      def destroy
+        if Dir.exist?(MODULE_DIR)
+          FileUtils.rm_rf(MODULE_DIR)
+          puts "  remove  #{MODULE_DIR}/"
+        else
+          puts "  skip    #{MODULE_DIR} (not found)"
+        end
+
+        %w[widgets.js ConnectWidget.jsx].each do |name|
+          path = File.join(frontend_dir, name)
+          next unless File.exist?(path)
+
+          File.delete(path)
+          puts "  remove  #{path}"
+        end
+
+        readme = File.join(WIDGETS_DIR, 'README.md')
+        if File.exist?(readme)
+          File.delete(readme)
+          puts "  remove  #{readme} (your <name>.js snippets are left in place)"
+        end
+
+        puts ''
+        puts '✓ Amazon Connect removed!'
+        puts "  Don't forget to remove the module reference from environment main.tf files,"
+        puts '  and tear down the Connect instance with `belt deploy <env>` (or terraform destroy).'
+      end
+
+      private
+
+      # Detect the host app's namespace from its routes file, falling back to the
+      # current directory name. Matches the belt-cost-monitoring convention.
+      def detect_namespace
+        routes_path = find_routes_file_path
+        if routes_path && (match = File.read(routes_path).match(/namespace :(\w+)/))
+          return match[1]
+        end
+
+        File.basename(Dir.pwd)
+      end
+
+      def find_routes_file_path
+        ['config/routes.tf.rb', 'infrastructure/routes.tf.rb', 'config/routes.rb'].find do |path|
+          File.exist?(path)
+        end
+      end
+
+      def generate_terraform_module
+        if Dir.exist?(MODULE_DIR) && !@force
+          puts "  skip    #{MODULE_DIR}/ (already exists, use --force to overwrite)"
+          return
+        end
+
+        FileUtils.mkdir_p(MODULE_DIR)
+        TERRAFORM_FILES.each do |template, filename|
+          write_template(template, File.join(MODULE_DIR, filename))
+        end
+      end
+
+      def generate_frontend
+        FRONTEND_FILES.each do |template, filename|
+          write_template(template, File.join(frontend_dir, filename))
+        end
+        generate_widgets_dir
+      end
+
+      # The bay for raw console snippets: a committed README explaining the
+      # convention, plus gitignore entries so the secret-bearing *.js never lands
+      # in git. Idempotent — re-running never duplicates the ignore lines.
+      def generate_widgets_dir
+        write_template(WIDGETS_README, File.join(WIDGETS_DIR, 'README.md'))
+
+        existing = File.exist?('.gitignore') ? File.read('.gitignore') : ''
+        return if existing.include?(GITIGNORE_LINES.last)
+
+        block = "#{GITIGNORE_LINES.join("\n")}\n"
+        File.write('.gitignore', existing.empty? ? block : "#{existing.chomp}\n\n#{block}")
+        puts "  update  .gitignore (ignore #{WIDGETS_DIR}/*.js)"
+      end
+
+      # Belt apps keep the React app under frontend/src; the older Stowzilla
+      # layout used app/src. The widget registry + generic loader live in a
+      # dedicated connect/ directory so the app has one obvious bay for widget
+      # wiring. Resolve at generation time against the app's CWD.
+      def frontend_dir
+        return 'app/src/connect' if Dir.exist?('app/src') && !Dir.exist?('frontend/src')
+
+        'frontend/src/connect'
+      end
+
+      def print_success
+        puts ''
+        puts '✓ Amazon Connect installed!'
+        puts ''
+        puts 'Next steps:'
+        puts '  1. Add the module to your environment main.tf:'
+        puts ''
+        puts '       module "connect" {'
+        puts '         source           = "../modules/connect"'
+        puts '         app_name         = var.app_name'
+        puts '         environment      = var.environment'
+        puts '         aws_region       = var.aws_region'
+        puts '         instance_alias   = "${var.app_name}-${var.environment}"'
+        puts '         approved_origins = ["https://${var.environment}.example.com"]'
+        puts '         # saml_metadata_file = "${path.module}/saml-metadata.xml"  # optional SSO'
+        puts '         # identity_management_type = "CONNECT_MANAGED"  # demo/sandbox: password logins'
+        puts '         # users = { "agent" = { security_profiles = ["Agent"] } }'
+        puts '       }'
+        puts ''
+        puts '  2. Deploy: belt deploy <env>'
+        puts '  3. Create a hosted chat widget in the Connect admin console (skip JWT'
+        puts '     security), save its "Get widget code" snippet to'
+        puts "     #{WIDGETS_DIR}/support.js (gitignored), then run:"
+        puts ''
+        puts '       belt generate connect add-widget support --env <env>'
+        puts ''
+        puts '     That parses the snippet into frontend/src/connect/widgets.js and writes'
+        puts '     the matched set (snippet id, widget url, element id) to SSM so the'
+        puts '     build injects it (the snippetId never lands in git).'
+        puts ''
+        puts '  4. Mount the widget anywhere:'
+        puts ''
+        puts "       import ConnectWidget, { openConnectChat } from './connect/ConnectWidget'"
+        puts '       <ConnectWidget name="support" />'
+        puts "       <button onClick={() => openConnectChat('support')}>Chat with us</button>"
+        puts ''
+        puts '  The chat widget is hosted by AWS and the browser WebSocket does the talking,'
+        puts '  so there is no runtime Lambda to deploy.'
+      end
+
+      def write_template(relative_template, destination, binding_context = binding)
+        source = File.join(TEMPLATE_DIR, relative_template)
+        unless File.exist?(source)
+          puts "  skip    missing template #{relative_template}"
+          return
+        end
+
+        if File.exist?(destination) && !@force
+          puts "  skip    #{destination} (already exists, use --force to overwrite)"
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(destination))
+        content = ERB.new(File.read(source), trim_mode: '-').result(binding_context)
+        File.write(destination, content)
+        puts "  create  #{destination}"
+      end
+    end
+  end
+end

data/lib/belt-connect.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'belt/connect'