belt 0.2.9 → 0.2.10

data/lib/belt/cli/doctor_command.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module Belt
+  module CLI
+    class DoctorCommand
+      REQUIRED_TOOLS = [
+        { name: 'aws', check: %w[aws --version],
+          install_url: 'https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html' },
+        { name: 'terraform', check: %w[terraform --version],
+          install_url: 'https://developer.hashicorp.com/terraform/install' },
+        { name: 'ruby', check: %w[ruby --version], min_version: '3.3' },
+        { name: 'bundler', check: %w[bundle --version], install_hint: 'gem install bundler' }
+      ].freeze
+
+      def self.run(args)
+        verbose = args.include?('--verbose') || args.include?('-v')
+
+        if args.include?('--help') || args.include?('-h')
+          puts usage
+          exit 0
+        end
+
+        new(verbose: verbose).run
+      end
+
+      def self.usage
+        <<~USAGE
+          Usage: belt doctor [options]
+
+          Check system dependencies and AWS configuration for Belt.
+
+          Options:
+            -v, --verbose    Show detailed output for each check
+            -h, --help       Show this help
+        USAGE
+      end
+
+      def initialize(verbose: false)
+        @verbose = verbose
+        @issues = []
+        @warnings = []
+      end
+
+      def run
+        puts "Belt Doctor\n"
+        puts "Checking your system for Belt prerequisites...\n\n"
+
+        check_tools
+        check_aws_credentials
+        check_aws_identity
+
+        puts ''
+        print_summary
+      end
+
+      private
+
+      def check_tools
+        puts '── Tools ──'
+        REQUIRED_TOOLS.each do |tool|
+          check_tool(tool)
+        end
+        puts ''
+      end
+
+      def check_tool(tool)
+        output, status = Open3.capture2e(*tool[:check])
+
+        if status.success?
+          version = extract_version(output)
+          if tool[:min_version] && version && Gem::Version.new(version) < Gem::Version.new(tool[:min_version])
+            print_warn(tool[:name], "found #{version}, need >= #{tool[:min_version]}")
+            @warnings << "#{tool[:name]} version #{version} is below minimum #{tool[:min_version]}"
+          else
+            print_ok(tool[:name], version ? version.to_s : output.strip.lines.first&.strip)
+          end
+        else
+          print_fail(tool[:name], 'not found')
+          hint = tool[:install_hint] || tool[:install_url]
+          puts "         Install: #{hint}" if hint
+          @issues << "#{tool[:name]} is not installed"
+        end
+      end
+
+      def check_aws_credentials
+        puts '── AWS Configuration ──'
+
+        # Check for credential sources
+        has_profile = ENV.fetch('AWS_PROFILE', nil) && !ENV['AWS_PROFILE'].empty?
+        has_env_keys = ENV.fetch('AWS_ACCESS_KEY_ID', nil) && !ENV['AWS_ACCESS_KEY_ID'].empty?
+        has_config_file = File.exist?(File.expand_path('~/.aws/config'))
+        has_credentials_file = File.exist?(File.expand_path('~/.aws/credentials'))
+
+        if has_profile
+          print_ok('AWS_PROFILE', ENV.fetch('AWS_PROFILE', nil))
+        elsif has_env_keys
+          print_ok('AWS_ACCESS_KEY_ID', 'set (environment variable)')
+        elsif has_credentials_file
+          print_ok('~/.aws/credentials', 'exists')
+        elsif has_config_file
+          print_ok('~/.aws/config', 'exists')
+        else
+          print_fail('AWS credentials', 'no credential source found')
+          puts '         Set AWS_PROFILE, or configure credentials via:'
+          puts '           aws configure sso    # SSO (recommended)'
+          puts '           aws configure        # access key + secret'
+          @issues << 'No AWS credentials configured'
+          return
+        end
+
+        # Check config file for profiles
+        return unless has_config_file && @verbose
+
+        profiles = parse_aws_config_profiles
+        puts "         Profiles: #{profiles.join(', ')}" if profiles.any?
+      end
+
+      def check_aws_identity
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+
+        if status.success?
+          data = begin
+            JSON.parse(output)
+          rescue JSON::ParserError
+            {}
+          end
+          account = data['Account'] || '?'
+          arn = data['Arn'] || '?'
+          print_ok('Authentication', "account #{account}")
+          puts "         ARN: #{arn}" if @verbose
+        else
+          error = output.strip
+          if error.include?('ExpiredToken') || error.include?('expired')
+            print_fail('Authentication', 'credentials expired')
+            puts '         Run: aws sso login'
+            @issues << 'AWS credentials are expired — run `aws sso login`'
+          elsif error.include?('InvalidClientTokenId') || error.include?('SignatureDoesNotMatch')
+            print_fail('Authentication', 'invalid credentials')
+            puts '         Your access key or secret is incorrect.'
+            puts '         Run: aws configure'
+            @issues << 'AWS credentials are invalid'
+          elsif error.include?('Could not connect') || error.include?('Unable to locate credentials')
+            print_fail('Authentication', 'unable to authenticate')
+            puts '         Run: aws configure sso    # or set AWS_PROFILE'
+            @issues << 'Unable to authenticate with AWS'
+          else
+            print_fail('Authentication', 'failed')
+            puts "         #{error.lines.first&.strip}" if error.length.positive?
+            @issues << 'AWS authentication failed'
+          end
+        end
+      end
+
+      def print_summary
+        if @issues.empty? && @warnings.empty?
+          puts '✓ All checks passed — you\'re ready to belt!'
+        elsif @issues.empty?
+          puts "⚠ #{@warnings.size} warning#{'s' if @warnings.size > 1}:"
+          @warnings.each { |w| puts "  • #{w}" }
+        else
+          puts "✗ #{@issues.size} issue#{'s' if @issues.size > 1} found:"
+          @issues.each { |i| puts "  • #{i}" }
+          @warnings.each { |w| puts "  • ⚠ #{w}" } if @warnings.any?
+          puts "\nFix the issues above, then run `belt doctor` again."
+          exit 1
+        end
+      end
+
+      def print_ok(label, detail = nil)
+        msg = "  ✓ #{label}"
+        msg += " — #{detail}" if detail
+        puts msg
+      end
+
+      def print_fail(label, detail = nil)
+        msg = "  ✗ #{label}"
+        msg += " — #{detail}" if detail
+        puts msg
+      end
+
+      def print_warn(label, detail = nil)
+        msg = "  ⚠ #{label}"
+        msg += " — #{detail}" if detail
+        puts msg
+      end
+
+      def extract_version(output)
+        # Match common version patterns:
+        #   "aws-cli/2.15.0" "Terraform v1.7.0" "Bundler version 2.5.0" "ruby 3.3.0"
+        match = output.match(%r{(?:version\s+|v|/|^ruby\s+)(\d+\.\d+(?:\.\d+)?)}i)
+        match ? match[1] : nil
+      end
+
+      def parse_aws_config_profiles
+        config_path = File.expand_path('~/.aws/config')
+        return [] unless File.exist?(config_path)
+
+        File.readlines(config_path)
+            .filter_map { |line| line.match(/\[profile\s+(.+)\]/)&.captures&.first }
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/belt/cli/environment_command.rb

@@ -26,11 +26,12 @@ module Belt
         new(env_name).generate
       end
 
-      def initialize(env_name, quiet: false, domain: nil)
+      def initialize(env_name, quiet: false, domain: nil, announce: true)
         @env_name = env_name.downcase.gsub(/[^a-z0-9_-]/, '')
         @app_name = detect_app_name
         @domain = domain
         @quiet = quiet
+        @announce = announce
       end
 
       def generate
@@ -41,19 +42,18 @@ module Belt
           exit 1
         end
 
-        puts "Creating environment: #{@env_name}"
+        puts "Creating environment: #{@env_name}" unless @quiet
         FileUtils.mkdir_p(dest_dir)
 
         templates.each do |template_name, dest_file|
           dest_path = File.join(dest_dir, dest_file)
           write_template(template_name, dest_path)
-          puts "  create  #{dest_path}"
+          puts "  create  #{dest_path}" unless @quiet
         end
 
-        puts "\n✓ Environment '#{@env_name}' created!"
-
-        return if @quiet
+        return if @quiet || !@announce
 
+        puts "\n✓ Environment '#{@env_name}' created!"
         puts "\nNext steps:"
         puts "  cd #{dest_dir}"
         puts '  terraform init'

data/lib/belt/cli/frontend_command.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 require 'erb'
 require 'json'
+require 'open3'
 require_relative 'app_detection'
 
 module Belt
@@ -28,8 +29,10 @@ module Belt
         new(framework).generate
       end
 
-      def initialize(framework)
+      def initialize(framework, quiet: false, announce: true)
         @framework = framework
+        @quiet = quiet
+        @announce = announce
         @app_name = detect_app_name
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
       end
@@ -42,7 +45,7 @@ module Belt
           exit 1
         end
 
-        puts "Creating #{@framework} frontend application..."
+        puts "Creating #{@framework} frontend application..." unless @quiet
         framework_dir = File.join(TEMPLATE_DIR, @framework)
 
         unless Dir.exist?(framework_dir)
@@ -52,25 +55,35 @@ module Belt
 
         copy_template(framework_dir, dest_dir)
 
-        puts "\n✓ Frontend (#{@framework}) created in frontend/"
+        puts "\n✓ Frontend (#{@framework}) created in frontend/" unless @quiet
 
         install_dependencies(dest_dir)
         setup_frontend_infra_for_existing_environments
 
+        return if @quiet || !@announce
+
         puts "\nNext steps:"
         puts '  belt server                   # Start local dev server'
         puts '  belt deploy                   # Deploy everything to AWS'
       end
 
+      def npm_ok?
+        @npm_ok != false
+      end
+
       private
 
       def install_dependencies(dest_dir)
-        puts "\n  Installing npm dependencies..."
-        success = system('npm', 'install', '--prefix', dest_dir, '--loglevel', 'error')
-        if success
-          puts '  ✓ Dependencies installed'
+        puts "\n  Installing npm dependencies..." unless @quiet
+        _output, status = Open3.capture2e(
+          'npm', 'install', '--prefix', dest_dir, '--no-fund', '--no-audit'
+        )
+        if status.success?
+          puts '  ✓ npm dependencies installed' unless @quiet
+          @npm_ok = true
         else
-          puts "  ⚠ npm install failed — run `cd #{dest_dir} && npm install` manually"
+          puts "  ⚠ npm install failed — run `cd #{dest_dir} && npm install` manually" unless @quiet
+          @npm_ok = false
         end
       end
 
@@ -79,16 +92,16 @@ module Belt
         frontend_tf = File.join(module_dir, 'frontend.tf')
 
         if File.exist?(frontend_tf)
-          puts "  skip    #{frontend_tf} (already exists)"
+          puts "  skip    #{frontend_tf} (already exists)" unless @quiet
           return
         end
 
         return unless Dir.exist?(module_dir)
 
-        puts "\n  Setting up frontend infrastructure..."
+        puts "\n  Setting up frontend infrastructure..." unless @quiet
         require_relative 'frontend_setup_command'
         FrontendSetupCommand.new(nil, quiet: true).run
-        puts "  create  #{frontend_tf}"
+        puts "  create  #{frontend_tf}" unless @quiet
       end
 
       def copy_template(src_dir, dest_dir)
@@ -107,7 +120,7 @@ module Belt
           else
             FileUtils.cp(src, dest_path)
           end
-          puts "  create  #{dest_path}"
+          puts "  create  #{dest_path}" unless @quiet
         end
       end
     end

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'