belt 0.2.9 → 0.2.11

data/lib/belt/cli/frontend_setup_command.rb

@@ -28,6 +28,7 @@ module Belt
       def run
         validate!
         generate_frontend_tf
+        ensure_cloudfront_cors
         return if @quiet
 
         puts "\n✓ Frontend infrastructure generated in #{MODULE_DIR}!"
@@ -51,6 +52,46 @@ module Belt
         File.write(dest, content)
         puts "  create  #{dest}" unless @quiet
       end
+
+      # Wire CloudFront origin into conveyor_belt frontend_urls so SPA→API CORS works.
+      # Handles common scaffold shapes so users never need the tutorial's manual CORS fix.
+      def ensure_cloudfront_cors
+        main_tf = File.join(MODULE_DIR, 'main.tf')
+        return unless File.exist?(main_tf)
+
+        content = File.read(main_tf)
+        return if content.include?('aws_cloudfront_distribution.frontend.domain_name')
+
+        replacement = lambda do |indent|
+          <<~TF.chomp
+            #{indent}# CloudFront first so SPA→API CORS works out of the box.
+            #{indent}frontend_urls = concat(
+            #{indent}  ["https://${aws_cloudfront_distribution.frontend.domain_name}"],
+            #{indent}  var.frontend_urls
+            #{indent})
+          TF
+        end
+
+        # `frontend_urls = var.frontend_urls`
+        simple = /^(\s*)frontend_urls\s*=\s*var\.frontend_urls\s*$/
+        if content.match?(simple)
+          content = content.sub(simple) { replacement.call(Regexp.last_match(1)) }
+          File.write(main_tf, content)
+          puts "  update  #{main_tf} (CloudFront CORS)" unless @quiet
+          return
+        end
+
+        # `frontend_urls = concat(var.frontend_urls)` or multi-line concat without CloudFront
+        concat_only = /^(\s*)frontend_urls\s*=\s*concat\(\s*\n?\s*var\.frontend_urls\s*\n?\s*\)\s*$/m
+        if content.match?(concat_only)
+          content = content.sub(concat_only) { replacement.call(Regexp.last_match(1)) }
+          File.write(main_tf, content)
+          puts "  update  #{main_tf} (CloudFront CORS)" unless @quiet
+          return
+        end
+
+        puts "  skip    #{main_tf} (add CloudFront to frontend_urls manually for CORS)" unless @quiet
+      end
     end
   end
 end

data/lib/belt/cli/new_command.rb

@@ -18,6 +18,7 @@ module Belt
         bucket = nil
         environments = nil
         domain = nil
+        verbose = false
 
         i = 0
         while i < args.length
@@ -49,6 +50,8 @@ module Belt
             domain = args[i]
           when /^--domain=/
             domain = arg.split('=', 2).last
+          when '-v', '--verbose'
+            verbose = true
           else
             app_name ||= arg unless arg.start_with?('-')
           end
@@ -65,22 +68,33 @@ module Belt
           puts '  --state-bucket BUCKET_NAME     Alias for --bucket'
           puts '  --environments dev,prod        Comma-separated environments (default: dev,prod)'
           puts '                                 Use "none" to skip environment setup'
+          puts '  -v, --verbose                  List every created file (Rails-style)'
           exit 1
         end
 
-        new(app_name, frontend: frontend, bucket: bucket, environments: environments, domain: domain).generate
+        new(
+          app_name,
+          frontend: frontend,
+          bucket: bucket,
+          environments: environments,
+          domain: domain,
+          verbose: verbose
+        ).generate
       end
 
-      def initialize(app_name, frontend: nil, bucket: nil, environments: nil, domain: nil)
+      # rubocop:disable Metrics/ParameterLists -- keyword options for generator flags
+      def initialize(app_name, frontend: nil, bucket: nil, environments: nil, domain: nil, verbose: false)
         @app_name = app_name.gsub(/[^a-z0-9_-]/i, '_').downcase
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @frontend = frontend
         @bucket = bucket
         @domain = domain
         @environments = parse_environments(environments)
+        @verbose = verbose
         @resolved_bucket = nil
         @state_setup_succeeded = false
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def generate
         if Dir.exist?(@app_name)
@@ -88,9 +102,12 @@ module Belt
           exit 1
         end
 
+        preflight_check
+
         puts "Creating new Belt application: #{@app_name}"
         create_structure
         generate_module
+        puts '  create  app skeleton' unless @verbose
         generate_environments
         generate_frontend if @frontend
         init_git
@@ -110,6 +127,19 @@ module Belt
         env_string.split(',').map(&:strip).reject(&:empty?)
       end
 
+      def preflight_check
+        missing = []
+        { 'aws' => 'AWS CLI', 'terraform' => 'Terraform' }.each do |cmd, label|
+          _, status = Open3.capture2e(cmd, '--version')
+          missing << label unless status.success?
+        end
+
+        return if missing.empty?
+
+        puts "⚠ Missing: #{missing.join(', ')}"
+        puts "  Belt requires these tools to deploy. Install them, then run `belt doctor` to verify.\n\n"
+      end
+
       def create_structure
         directories.each { |dir| create_dir(dir) }
         files.each { |src, dest| create_file(src, dest) }
@@ -162,7 +192,7 @@ module Belt
           template_path = File.join(module_template_dir, template_name)
           content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
           File.write(dest_path, content)
-          puts "  create  #{dest_path}"
+          puts "  create  #{dest_path}" if @verbose
         end
       end
 
@@ -171,43 +201,62 @@ module Belt
 
         Dir.chdir(@app_name) do
           @environments.each do |env_name|
-            Belt::CLI::EnvironmentCommand.new(env_name, quiet: true, domain: @domain).generate
+            Belt::CLI::EnvironmentCommand.new(
+              env_name,
+              quiet: !@verbose,
+              announce: false,
+              domain: @domain
+            ).generate
           end
         end
+        puts "  create  environments (#{@environments.join(', ')})" unless @verbose
       end
 
       def setup_state
         return if @environments.empty?
 
-        Dir.chdir(@app_name) do
-          # Shared bucket: one per AWS account, all belt apps share it
-          @resolved_bucket = @bucket || 'belt-terraform-state'
-
-          # Attempt to actually create the bucket if credentials are available
-          if aws_configured?
-            puts "\n  Setting up Terraform state bucket..."
-            begin
-              Belt::CLI::SetupCommand.new(['--bucket', @resolved_bucket]).run_state_setup
-              @state_setup_succeeded = true
-            rescue SystemExit
-              puts '  ⚠ State bucket setup encountered an issue — run `belt setup state` to retry.'
-              @state_setup_succeeded = false
-            end
-          else
-            puts "\n  State bucket: #{@resolved_bucket}"
-            puts "  State keys:   #{s3_safe_name(@app_name)}/<env>/terraform.tfstate"
-            if @aws_error&.include?('ForbiddenException') || @aws_error&.include?('AccessDenied')
-              puts '  ⚠ AWS credentials found but access denied — check your profile/role configuration.'
-              puts "    #{@aws_error}" if @aws_error
-            else
-              puts '  ⚠ AWS credentials not detected — skipping state bucket creation.'
-            end
-            puts '  Run `belt setup state` after configuring credentials (aws sso login / AWS_PROFILE).'
-            @state_setup_succeeded = false
-          end
+        Dir.chdir(@app_name) { create_or_skip_state_bucket }
+      end
+
+      def create_or_skip_state_bucket
+        # Shared bucket: one per AWS account, all belt apps share it.
+        # Account ID suffix makes the name globally unique (S3 is a global namespace).
+        @resolved_bucket = if @bucket
+                             @bucket
+                           elsif aws_configured?
+                             "belt-terraform-state-#{@aws_account_id}"
+                           else
+                             'belt-terraform-state'
+                           end
+
+        if aws_configured?
+          create_state_bucket!
+        else
+          warn_missing_aws_for_state
+          @state_setup_succeeded = false
         end
       end
 
+      def create_state_bucket!
+        setup = Belt::CLI::SetupCommand.new(['--bucket', @resolved_bucket], quiet: true)
+        setup.run_state_setup
+        @resolved_bucket = setup.bucket_name
+        @state_setup_succeeded = true
+        puts "  ✓      state bucket #{@resolved_bucket}"
+      rescue SystemExit
+        puts '  ⚠      state bucket setup failed — run `belt setup state` to retry'
+        @state_setup_succeeded = false
+      end
+
+      def warn_missing_aws_for_state
+        if @aws_error&.include?('ForbiddenException') || @aws_error&.include?('AccessDenied')
+          puts '  ⚠      AWS credentials found but access denied — check profile/role'
+        else
+          puts '  ⚠      AWS credentials not detected — skipped state bucket'
+        end
+        puts '         run `belt doctor`, then `belt setup state`'
+      end
+
       def aws_configured?
         output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
         if status.success?
@@ -226,45 +275,64 @@ module Belt
 
       def create_dir(dir)
         FileUtils.mkdir_p(dir)
-        puts "  create  #{dir}/"
+        puts "  create  #{dir}/" if @verbose
       end
 
       def create_file(template_name, dest_path)
         template_path = File.join(TEMPLATE_DIR, template_name)
         content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
         File.write(dest_path, content)
-        puts "  create  #{dest_path}"
+        puts "  create  #{dest_path}" if @verbose
       end
 
       def init_git
         Dir.chdir(@app_name) do
           system('git', 'init', '--quiet')
         end
-        puts "  init    #{@app_name}/.git/"
+        if @verbose
+          puts "  init    #{@app_name}/.git/"
+        else
+          puts '  init    git'
+        end
       end
 
       def run_bundle_install
         Dir.chdir(@app_name) do
-          puts "\n  Running bundle install..."
+          puts "\n  Running bundle install..." if @verbose
+          # Always --quiet: bundle's own progress is noise either way
           success = system('bundle', 'install', '--quiet')
           if success
-            puts '  ✓ Bundle installed'
+            puts '  ✓      bundle install'
           else
-            puts '  ⚠ bundle install failed — run it manually after resolving issues.'
+            puts '  ⚠      bundle install failed — run it manually after resolving issues'
           end
         end
       end
 
       def generate_frontend
+        frontend_cmd = nil
         Dir.chdir(@app_name) do
-          Belt::CLI::FrontendCommand.new(@frontend).generate
+          frontend_cmd = Belt::CLI::FrontendCommand.new(
+            @frontend,
+            quiet: !@verbose,
+            announce: false
+          )
+          frontend_cmd.generate
+        end
+        return if @verbose
+
+        puts "  create  frontend (#{@frontend})"
+        if frontend_cmd.npm_ok?
+          puts '  ✓      npm dependencies'
+        else
+          puts '  ⚠      npm install failed — run `cd frontend && npm install`'
         end
       end
 
       def print_next_steps
         puts "\nNext steps:"
         unless @state_setup_succeeded
-          puts '  # Configure AWS credentials (aws sso login / AWS_PROFILE)'
+          puts '  belt doctor                   # Verify AWS CLI, Terraform & credentials'
           puts '  belt setup state              # Create the S3 state bucket'
         end
         puts '  belt deploy                   # Deploy to AWS'

data/lib/belt/cli/path_gem_materializer.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'rubygems/package'
+
+module Belt
+  module CLI
+    # Turns Gemfile `path:` gems into real `.gem` files in vendor/cache and
+    # rewrites the Gemfile/lock so Docker `bundle install` produces a normal
+    # gem install (with specifications/). Required for Lambda bare `require`
+    # without bundler/setup.
+    #
+    # Only mutates files under +build_dir+ — never the app's real Gemfile.
+    class PathGemMaterializer
+      PathSource = Struct.new(:remote, :gems, keyword_init: true)
+      PathGem = Struct.new(:name, :version, keyword_init: true)
+
+      def self.materialize!(build_dir, project_root:)
+        new(build_dir, project_root: project_root).materialize!
+      end
+
+      def initialize(build_dir, project_root:)
+        @build_dir = build_dir
+        @project_root = project_root
+        @gemfile = File.join(build_dir, 'Gemfile')
+        @lockfile = File.join(build_dir, 'Gemfile.lock')
+      end
+
+      # @return [Array<String>] names of gems materialized (empty if none)
+      def materialize!
+        return [] unless File.exist?(@gemfile) && File.exist?(@lockfile)
+
+        sources = parse_path_sources(File.read(@lockfile))
+        return [] if sources.empty?
+
+        cache_dir = File.join(@build_dir, 'vendor', 'cache')
+        FileUtils.mkdir_p(cache_dir)
+
+        materialized = []
+        sources.each do |source|
+          source_path = resolve_remote(source.remote)
+          abort "✗ path gem source missing: #{source.remote} (resolved #{source_path})" unless Dir.exist?(source_path)
+
+          source.gems.each do |gem|
+            gem_file = build_gem(source_path, gem)
+            dest = File.join(cache_dir, File.basename(gem_file))
+            FileUtils.cp(gem_file, dest)
+            FileUtils.rm_f(gem_file)
+            rewrite_gemfile_path_to_version!(gem.name, gem.version)
+            materialized << gem.name
+          end
+        end
+
+        return [] if materialized.empty?
+
+        relock!(materialized)
+        materialized
+      end
+
+      private
+
+      def parse_path_sources(lockfile_content)
+        sources = []
+        lockfile_content.scan(/^PATH\n  remote: (.+)\n  specs:\n((?:    .+\n)*)/) do |remote, specs_block|
+          gems = []
+          specs_block.each_line do |line|
+            next unless line.match?(/^    \S/)
+            next if line.start_with?('      ') # dependency lines are deeper
+
+            match = line.match(/^    (\S+)\s+\(([^)]+)\)/)
+            gems << PathGem.new(name: match[1], version: match[2]) if match
+          end
+          sources << PathSource.new(remote: remote.strip, gems: gems) if gems.any?
+        end
+        sources
+      end
+
+      def resolve_remote(remote)
+        return remote if remote.start_with?('/')
+
+        File.expand_path(remote, @project_root)
+      end
+
+      def build_gem(source_path, gem)
+        gemspec = find_gemspec(source_path, gem.name)
+        abort "✗ No gemspec for path gem #{gem.name} under #{source_path}" unless gemspec
+
+        Dir.chdir(source_path) do
+          spec = Gem::Specification.load(File.basename(gemspec))
+          abort "✗ Failed to load #{gemspec}" unless spec
+
+          if spec.version.to_s != gem.version
+            abort "✗ path gem #{gem.name} version mismatch: gemspec #{spec.version}, lock #{gem.version}"
+          end
+
+          # Gem::Package.build writes the .gem into cwd
+          built = Gem::Package.build(spec)
+          File.expand_path(built)
+        end
+      end
+
+      def find_gemspec(source_path, gem_name)
+        preferred = File.join(source_path, "#{gem_name}.gemspec")
+        return preferred if File.exist?(preferred)
+
+        Dir.glob(File.join(source_path, '*.gemspec')).first
+      end
+
+      def rewrite_gemfile_path_to_version!(name, version)
+        content = File.read(@gemfile)
+        new_content = content.lines.map { |line| convert_path_line(line, name, version) }.join
+        abort "✗ Could not rewrite path: for gem #{name.inspect} in build Gemfile" if new_content == content
+        File.write(@gemfile, new_content)
+      end
+
+      # Converts `gem 'name', path: '...'` (and variants with other kwargs) into
+      # a version-pinned line. Leaves non-matching lines alone.
+      def convert_path_line(line, name, version)
+        return line unless line.match?(/gem\s+(['"])#{Regexp.escape(name)}\1/)
+        return line unless line.match?(/\bpath:\s*/)
+
+        quote = line[/gem\s+(['"])/, 1] || "'"
+        cleaned = line.sub(/,?\s*path:\s*['"][^'"]+['"]/, '')
+        cleaned.sub(/gem\s+(['"])#{Regexp.escape(name)}\1/) do
+          "gem #{quote}#{name}#{quote}, #{quote}#{version}#{quote}"
+        end
+      end
+
+      def relock!(gem_names)
+        Dir.chdir(@build_dir) do
+          # vendor/cache has the built .gem — Bundler resolves the unpublished version
+          output, status = Open3.capture2e('bundle', 'lock', '--update', *gem_names)
+          return if status.success?
+
+          abort "✗ Failed to re-lock after materializing path gems (#{gem_names.join(', ')}):\n#{output}"
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/plugin_command.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+
+module Belt
+  module CLI
+    # Scaffold a new Belt plugin gem (similar to `rails plugin new`).
+    #
+    # Usage:
+    #   belt plugin new messaging
+    #   belt plugin new belt-pay --path ~/code
+    #
+    # Creates a gem that registers with Belt's GeneratorRegistry via:
+    #   lib/belt/generators/<name>_generator.rb
+    class PluginCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/plugin', __dir__)
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'new'
+          new(args).generate
+        when nil, '--help', '-h', 'help'
+          print_help
+        else
+          puts "Unknown plugin subcommand: #{subcommand}"
+          puts ''
+          print_help
+          exit 1
+        end
+      end
+
+      def self.print_help
+        puts <<~HELP
+          Manage Belt plugin gems.
+
+          Usage:
+            belt plugin new <name> [options]
+
+          Arguments:
+            name                    Plugin name (e.g. messaging, pay, or belt-messaging)
+
+          Options:
+            --path DIR              Parent directory for the gem (default: current directory)
+            --summary TEXT          Short gem summary for the gemspec
+            --force                 Overwrite files if the directory already exists
+            -h, --help              Show this help
+
+          Examples:
+            belt plugin new messaging
+            belt plugin new pay --path ~/Code
+            belt plugin new belt-notifications --summary "Push notifications for Belt apps"
+
+          What you get:
+            A standalone gem (belt-<name>) with:
+              - Module under Belt::<Name>
+              - Generator at lib/belt/generators/<name>_generator.rb
+              - Configuration stub, version, RSpec, README, AGENTS.md
+              - Hooked into `belt generate <name>` / `belt destroy <name>` once
+                the gem is in an app's Gemfile
+
+          Reference plugins:
+            belt-messaging  — SMS via AWS End User Messaging
+            belt-pay        — Stripe payments and subscriptions
+
+          See the Belt README (Plugins / Contributing) and AGENTS.md for the full guide.
+        HELP
+      end
+
+      def initialize(args)
+        @raw_name = nil
+        @path = Dir.pwd
+        @summary = nil
+        @force = false
+
+        i = 0
+        while i < args.length
+          arg = args[i]
+          case arg
+          when '--path'
+            i += 1
+            @path = args[i] || Dir.pwd
+          when /^--path=/
+            @path = arg.split('=', 2).last
+          when '--summary'
+            i += 1
+            @summary = args[i]
+          when /^--summary=/
+            @summary = arg.split('=', 2).last
+          when '--force'
+            @force = true
+          when '--help', '-h'
+            self.class.print_help
+            exit 0
+          else
+            if arg.start_with?('-')
+              puts "Unknown option: #{arg}"
+              exit 1
+            end
+            @raw_name ||= arg
+          end
+          i += 1
+        end
+      end
+
+      def generate
+        if @raw_name.nil? || @raw_name.strip.empty?
+          puts 'Usage: belt plugin new <name> [options]'
+          puts "Run 'belt plugin --help' for more information."
+          exit 1
+        end
+
+        normalize_names!
+
+        if Dir.exist?(@gem_dir) && !@force
+          puts "✗ Directory already exists: #{@gem_dir}"
+          puts '  Use --force to overwrite, or choose a different name/path.'
+          exit 1
+        end
+
+        FileUtils.mkdir_p(@gem_dir)
+        write_files
+        print_success
+      end
+
+      private
+
+      def normalize_names!
+        # Accept "messaging", "belt-messaging", "Belt::Messaging"
+        name = @raw_name.to_s.strip
+        name = name.sub(/\ABelt::/i, '')
+        name = name.gsub('::', '-')
+        name = name.sub(/\Abelt[-_]/i, '')
+        name = name.gsub(/[^a-z0-9_-]/i, '_').downcase.tr('_', '-')
+        name = name.gsub(/-+/, '-').gsub(/\A-|-\z/, '')
+
+        if name.empty?
+          puts "✗ Invalid plugin name: #{@raw_name.inspect}"
+          exit 1
+        end
+
+        @plugin_name = name # messaging
+        @gem_name = "belt-#{name}" # belt-messaging
+        @module_name = name.split('-').map(&:capitalize).join # Messaging
+        @constant_path = "Belt::#{@module_name}" # Belt::Messaging
+        @generator_class = "#{@module_name}Generator"
+        @summary ||= "#{@module_name} plugin for Belt applications"
+        @gem_dir = File.expand_path(File.join(@path, @gem_name))
+      end
+
+      def write_files
+        files.each do |relative, content|
+          full = File.join(@gem_dir, relative)
+          FileUtils.mkdir_p(File.dirname(full))
+          File.write(full, content)
+          puts "  create  #{File.join(@gem_name, relative)}"
+        end
+      end
+
+      def files
+        gen = "lib/belt/generators/#{@plugin_name.tr('-', '_')}_generator.rb"
+        {
+          "#{@gem_name}.gemspec" => render('gemspec.erb'),
+          'Gemfile' => render('Gemfile.erb'),
+          'Rakefile' => render('Rakefile.erb'),
+          'README.md' => render('README.md.erb'),
+          'AGENTS.md' => render('AGENTS.md.erb'),
+          'CHANGELOG.md' => render('CHANGELOG.md.erb'),
+          'LICENSE' => render('LICENSE.erb'),
+          '.gitignore' => render('gitignore.erb'),
+          '.rspec' => render('rspec.erb'),
+          "lib/#{@gem_name}.rb" => render('lib/entry.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}.rb" => render('lib/belt/module.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/version.rb" => render('lib/belt/module/version.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/configuration.rb" => render('lib/belt/module/configuration.rb.erb'),
+          gen => render('lib/belt/generators/generator.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/templates/.gitkeep" => '',
+          'spec/spec_helper.rb' => render('spec/spec_helper.rb.erb'),
+          "spec/belt/#{@plugin_name.tr('-', '_')}/configuration_spec.rb" => render('spec/configuration_spec.rb.erb')
+        }
+      end
+
+      def render(template_name)
+        path = File.join(TEMPLATE_DIR, template_name)
+        raise "Missing plugin template: #{path}" unless File.exist?(path)
+
+        erb = ERB.new(File.read(path), trim_mode: '-')
+        # Expose locals used in templates
+        gem_name = @gem_name
+        plugin_name = @plugin_name
+        module_name = @module_name
+        constant_path = @constant_path
+        generator_class = @generator_class
+        summary = @summary
+        underscored = @plugin_name.tr('-', '_')
+        erb.result(binding)
+      end
+
+      def print_success
+        puts ''
+        puts "✓ Created plugin gem #{@gem_name}"
+        puts ''
+        puts 'Next steps:'
+        puts "  1. cd #{@gem_dir}"
+        puts '  2. bundle install'
+        puts '  3. Implement your library under lib/belt/'
+        puts "  4. Flesh out lib/belt/generators/#{@plugin_name.tr('-', '_')}_generator.rb"
+        puts '     (templates go in lib/belt/<name>/templates/)'
+        puts '  5. In a Belt app Gemfile:'
+        puts "       gem \"#{@gem_name}\", path: \"#{@gem_dir}\""
+        puts '  6. bundle install && belt generate --help'
+        puts "     → should list \"#{@plugin_name}\" under Gem Generators"
+        puts "  7. belt generate #{@plugin_name}"
+        puts ''
+        puts 'Reference implementations: belt-messaging, belt-pay'
+      end
+    end
+  end
+end