belt 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 330331693d70f3a18ad04c47b4f0b07c69b6a75538291be891946e12c7863dfc
-  data.tar.gz: 643ed0cad19c1124581d86b7f816ce199d372be0415c03b53c8f9d5f990bc3a9
+  metadata.gz: 479b619266e398d1d3052c96eb18f05c8452306a01aa46576b82e072372820b5
+  data.tar.gz: d5697750193b1a1cbba8d39e81190035d8fd40db490efbdb24903e7647374767
 SHA512:
-  metadata.gz: ca9f5d87f6b8ab597106789e5a381aa3ba6f33b85cc2620552b8c9380ad5508d7f27d5ed34cea52b59858db91ab02653ee4a487044562f7c3c68739c3fa40779
-  data.tar.gz: 36cbc894c45482981d1c3ddd34f0b59dd7e5259dd5de975175af756c54488693e6b0396c44b81b396442149a70ff6067d8d40046cef749d7119d248f49d57990
+  metadata.gz: 73ac84ffd0e2238b929180f89972f70c55a7d43a92d0f9de23b85cc6c318982c40c9466f49fe1d2d0960a47685acc90e1352b43f7e390ffee2951c83568ba432
+  data.tar.gz: 74db2374a336ba5ac774a5a8a4f7c053136de9dc652907e4abeebd69ec6bfa6485f35d3339787e7e5b17feadb3cf23014ae356d8050e817c90a2ba1fbf817ba6

data/lib/belt/assets/welcome.css

@@ -23,7 +23,7 @@ body {
   left: 50%;
   transform: translate(-50%, -50%);
   padding: 2rem 3rem;
-  background: rgba(255, 255, 255, 0.88);
+  background: rgba(255, 255, 255, 0.50);
   backdrop-filter: blur(6px);
   -webkit-backdrop-filter: blur(6px);
   border-radius: 12px;

data/lib/belt/cli/app_detection.rb

@@ -3,7 +3,9 @@
 module Belt
   module CLI
     module AppDetection
-      def detect_app_name
+      # Detects the primary namespace from the route definitions.
+      # Used by generators to determine controller directory and route file naming.
+      def detect_namespace
         routes_file = 'infrastructure/routes.tf.rb'
         if File.exist?(routes_file)
           match = File.read(routes_file).match(/namespace :(\w+)/)
@@ -12,6 +14,26 @@ module Belt
         File.basename(Dir.pwd)
       end
 
+      # Detects the application name.
+      # Prefers terraform.tfvars app_name, then falls back to directory name.
+      def detect_app_name
+        # Check any environment tfvars for the app_name
+        Dir.glob('infrastructure/*/terraform.tfvars').each do |f|
+          content = File.read(f)
+          match = content.match(/app_name\s*=\s*"([^"]+)"/)
+          return match[1] if match
+        end
+
+        # Fall back to directory name
+        File.basename(Dir.pwd)
+      end
+
+      # Detects existing environments by scanning infrastructure/ directories.
+      # Each subdirectory with a main.tf is considered an environment.
+      def detect_environments
+        Dir.glob('infrastructure/*/main.tf').map { |f| File.basename(File.dirname(f)) }.sort
+      end
+
       # S3 bucket names follow DNS rules — underscores are not allowed.
       # App names often use underscores (Ruby namespaces); convert for S3.
       def s3_safe_name(name)

data/lib/belt/cli/deploy_command.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+require 'json'
+require 'open3'
+require 'tmpdir'
 require_relative 'env_resolver'
 require_relative 'terraform_command'
 
@@ -15,12 +19,15 @@ module Belt
         end
 
         auto_approve = false
+        rebuild = false
         filtered_args = []
 
         args.each do |arg|
           case arg
           when '--auto', '--yes', '-y'
             auto_approve = true
+          when '--rebuild'
+            rebuild = true
           when '-h', '--help'
             puts help_text
             exit 0
@@ -41,18 +48,24 @@ module Belt
             puts "\nDefaults to BELT_ENV or the first available environment."
             puts "\nOptions:"
             puts '  --auto, --yes, -y    Skip confirmation prompt (auto-approve)'
+            puts '  --rebuild            Rebuild and push Lambda code directly (bypasses Terraform)'
             puts '  -h, --help           Show this help'
             puts "\nExamples:"
             puts '  belt deploy                # Deploy dev (or BELT_ENV)'
             puts '  belt deploy prod           # Deploy to prod'
             puts '  belt deploy dev --auto     # Deploy without confirmation'
+            puts '  belt deploy --rebuild      # Fast code push (no infra changes)'
             puts '  belt deploy frontend dev   # Deploy frontend only'
             puts "\nNo environments found. Run `belt generate environment dev` first."
             exit 1
           end
         end
 
-        new(env, auto_approve: auto_approve, extra_args: filtered_args).run
+        if rebuild
+          new(env, auto_approve: auto_approve, extra_args: filtered_args).run_rebuild
+        else
+          new(env, auto_approve: auto_approve, extra_args: filtered_args).run
+        end
       end
 
       def self.help_text
@@ -63,22 +76,28 @@ module Belt
                  belt deploy frontend <environment>
 
           This runs the full deployment lifecycle:
-            1. terraform init    (initialize providers/modules)
-            2. terraform plan    (preview changes)
-            3. Prompt for confirmation (unless --auto)
-            4. terraform apply   (deploy changes)
+            1. Ensure Gemfile.lock is consistent (fix stale PATH refs)
+            2. terraform init    (initialize providers/modules)
+            3. terraform plan    (preview changes)
+            4. Prompt for confirmation (unless --auto)
+            5. terraform apply   (deploy changes)
 
           Options:
             --auto, --yes, -y    Skip confirmation prompt (auto-approve)
+            --rebuild            Rebuild and push Lambda code directly (bypasses Terraform).
+                                 Much faster for code-only changes — packages gems via Docker,
+                                 zips, and pushes with `aws lambda update-function-code`.
             -h, --help           Show this help
 
           Environment:
-            Defaults to BELT_ENV if set, otherwise requires an argument.
+            Defaults to BELT_ENV if set, otherwise the first available environment.
 
           Examples:
             belt deploy                # Deploy dev (or BELT_ENV)
             belt deploy prod           # Deploy to prod
             belt deploy dev --auto     # Deploy without confirmation (CI mode)
+            belt deploy --rebuild      # Fast code push to dev (no infra changes)
+            belt deploy prod --rebuild # Fast code push to prod
             belt deploy frontend dev   # Deploy frontend assets only
         HELP
       end
@@ -88,6 +107,7 @@ module Belt
         @auto_approve = auto_approve
         @extra_args = extra_args
         @infra_dir = TerraformCommand.find_infrastructure_dir
+        @project_root = find_project_root
       end
 
       def run
@@ -96,6 +116,8 @@ module Belt
 
         puts "belt → deploying #{@env} (in #{env_dir}/)\n\n"
 
+        ensure_lockfile_consistent!
+
         Dir.chdir(env_dir) do
           run_init
           run_plan
@@ -105,11 +127,49 @@ module Belt
 
         puts "\n✅ Deployed #{@env} successfully!"
         print_outputs(env_dir)
+
+        deploy_frontend_if_exists
+
         puts "\n   Run `belt server` to view your app locally (auto-connects to the deployed API)."
       end
 
+      def run_rebuild
+        validate!
+        validate_aws!
+
+        puts "belt → rebuilding Lambda for #{@env}\n\n"
+
+        lambda_dir = find_lambda_dir
+        abort 'Error: Cannot find lambda/ directory.' unless lambda_dir
+
+        function_name = find_lambda_function_name
+        abort 'Error: Cannot determine Lambda function name from Terraform state.' unless function_name
+
+        ensure_lockfile_consistent!
+        generate_routes(lambda_dir)
+        build_and_deploy(lambda_dir, function_name)
+      end
+
       private
 
+      def find_project_root
+        # Walk up from infra dir to find project root (where Gemfile lives)
+        dir = @infra_dir ? File.dirname(@infra_dir) : Dir.pwd
+        while dir != '/'
+          return dir if File.exist?(File.join(dir, 'Gemfile'))
+          dir = File.dirname(dir)
+        end
+        Dir.pwd
+      end
+
+      def find_lambda_dir
+        candidates = [
+          File.join(@project_root, 'lambda'),
+          File.join(Dir.pwd, 'lambda')
+        ]
+        candidates.find { |d| Dir.exist?(d) }
+      end
+
       def validate!
         unless @infra_dir
           abort "Error: No infrastructure/ directory found.\n" \
@@ -124,6 +184,262 @@ module Belt
               "Create it with: belt generate environment #{@env}"
       end
 
+      def validate_aws!
+        stdout, status = Open3.capture2('aws', 'sts', 'get-caller-identity', '--output', 'json')
+        unless status.success?
+          abort "Error: AWS credentials not available.\n" \
+                "Run `aws sso login` or configure AWS_PROFILE."
+        end
+        @aws_account = JSON.parse(stdout)['Account'] rescue nil
+      end
+
+      # Ensure Gemfile.lock doesn't have stale PATH references that will break
+      # the Docker-based gem build. If the Gemfile no longer uses `path:` but the
+      # lockfile still references a PATH source, refresh the lock.
+      def ensure_lockfile_consistent!
+        gemfile = File.join(@project_root, 'Gemfile')
+        lockfile = File.join(@project_root, 'Gemfile.lock')
+        return unless File.exist?(gemfile) && File.exist?(lockfile)
+
+        gemfile_content = File.read(gemfile)
+        lockfile_content = File.read(lockfile)
+
+        # Find gems that are PATH-sourced in the lockfile but NOT path-sourced in the Gemfile
+        stale_path_gems = detect_stale_path_gems(gemfile_content, lockfile_content)
+        return if stale_path_gems.empty?
+
+        puts "  🔧 Fixing stale Gemfile.lock (#{stale_path_gems.join(', ')} referenced as PATH but Gemfile uses RubyGems)"
+        Dir.chdir(@project_root) do
+          success = system('bundle', 'lock', '--update', *stale_path_gems)
+          unless success
+            puts "  ⚠ `bundle lock --update #{stale_path_gems.join(' ')}` failed — trying full bundle update"
+            system('bundle', 'update', *stale_path_gems)
+          end
+        end
+        puts ''
+      end
+
+      def detect_stale_path_gems(gemfile_content, lockfile_content)
+        stale = []
+
+        # Parse PATH sections from lockfile
+        # Format:
+        #   PATH
+        #     remote: ../something
+        #     specs:
+        #       gem_name (version)
+        lockfile_content.scan(/^PATH\n\s+remote:.*?\n\s+specs:\n((?:\s{4}\S.*\n?)+)/m).each do |match|
+          match[0].scan(/^\s{4}(\S+)\s/).each do |gem_match|
+            gem_name = gem_match[0]
+            # Check if the Gemfile still uses path: for this gem
+            # Match patterns like: gem 'name', path: ... or gem "name", path: ...
+            has_path_in_gemfile = gemfile_content.match?(/gem\s+['"]#{Regexp.escape(gem_name)}['"].*path:/)
+            stale << gem_name unless has_path_in_gemfile
+          end
+        end
+
+        stale
+      end
+
+      def find_lambda_function_name
+        env_dir = File.join(@infra_dir, @env)
+        return nil unless Dir.exist?(File.join(env_dir, '.terraform'))
+
+        # Get function name from terraform state
+        Dir.chdir(env_dir) do
+          output, status = Open3.capture2('terraform', 'output', '-json')
+          return nil unless status.success?
+
+          data = JSON.parse(output) rescue {}
+
+          # Try lambda_functions output first
+          if data['lambda_functions']
+            funcs = data['lambda_functions']['value']
+            if funcs.is_a?(Hash) && funcs.any?
+              return funcs.values.first # ARN — we need just the function name
+            end
+          end
+
+          # Fallback: parse from terraform state directly
+          state_output, state_status = Open3.capture2('terraform', 'state', 'show', 'conveyor_belt.main')
+          return nil unless state_status.success?
+
+          # Look for lambda function names in state
+          state_output.match(/function_name\s*=\s*"([^"]+)"/)&.captures&.first
+        end
+      end
+
+      def generate_routes(lambda_dir)
+        routes_dir = File.join(lambda_dir, 'lib', 'routes')
+        return unless Dir.exist?(routes_dir)
+
+        puts '  🗺️  Regenerating route manifests...'
+        success = system('belt', 'routes', '--namespace', 'all', '--output-dir', routes_dir)
+        if success
+          puts '  ✅ Routes updated'
+        else
+          puts '  ⚠ Route generation failed — using existing manifests'
+        end
+        puts ''
+      end
+
+      def build_and_deploy(lambda_dir, function_identifier)
+        # Extract function name from ARN if needed
+        function_name = if function_identifier.include?(':')
+                          function_identifier.split(':').last
+                        else
+                          function_identifier
+                        end
+
+        build_dir = Dir.mktmpdir('belt-rebuild-')
+
+        begin
+          puts '  📦 Building Lambda package...'
+          assemble_package(lambda_dir, build_dir)
+          build_gems(build_dir)
+          zip_file = create_zip(build_dir)
+
+          puts '  🚀 Deploying to AWS...'
+          deploy_to_lambda(function_name, zip_file)
+
+          puts "\n✅ Lambda #{function_name} rebuilt and deployed!"
+          puts ''
+          puts '  📋 View logs:'
+          puts "    aws logs tail /aws/lambda/#{function_name} --follow"
+        ensure
+          FileUtils.rm_rf(build_dir)
+        end
+      end
+
+      def assemble_package(lambda_dir, build_dir)
+        # Copy handler file(s) — .rb files at root of lambda/
+        Dir.glob(File.join(lambda_dir, '*.rb')).each do |f|
+          FileUtils.cp(f, build_dir)
+        end
+
+        # Copy shared directories
+        %w[controllers models lib helpers templates serializers jobs config].each do |dir|
+          src = File.join(lambda_dir, dir)
+          FileUtils.cp_r(src, File.join(build_dir, dir)) if Dir.exist?(src)
+        end
+
+        # Copy Gemfile from project root
+        gemfile = File.join(@project_root, 'Gemfile')
+        lockfile = File.join(@project_root, 'Gemfile.lock')
+        FileUtils.cp(gemfile, build_dir) if File.exist?(gemfile)
+        FileUtils.cp(lockfile, build_dir) if File.exist?(lockfile)
+
+        puts '    📁 Copied handlers, controllers, models, lib, config'
+      end
+
+      def build_gems(build_dir)
+        puts '    🐳 Building gems in Docker (Lambda-compatible)...'
+
+        docker_cmd = [
+          'docker', 'run', '--rm',
+          '--platform', 'linux/amd64',
+          '-v', "#{build_dir}:/var/task",
+          '-w', '/var/task',
+          'public.ecr.aws/sam/build-ruby3.4:latest-x86_64',
+          '/bin/bash', '-c',
+          "bundle config set --local path 'vendor/bundle' && " \
+          "bundle config set --local without 'development test' && " \
+          'bundle config set silence_root_warning 1 && ' \
+          'bundle install --jobs 4 && ' \
+          'bundle clean --force'
+        ]
+
+        output, status = Open3.capture2e(*docker_cmd)
+        unless status.success?
+          puts output
+          abort "\n✗ Gem build failed. Check Docker is running and the Gemfile is valid."
+        end
+
+        # Strip fat from vendor bundle
+        strip_vendor_fat(build_dir)
+        puts '    ✅ Gems installed'
+      end
+
+      def strip_vendor_fat(build_dir)
+        vendor_dir = File.join(build_dir, 'vendor')
+        return unless Dir.exist?(vendor_dir)
+
+        # Remove docs, tests, and non-runtime files from gems
+        Dir.glob(File.join(vendor_dir, 'bundle/ruby/*/gems/*/')).each do |gem_dir|
+          %w[spec test tests doc docs examples benchmarks].each do |fat_dir|
+            FileUtils.rm_rf(File.join(gem_dir, fat_dir))
+          end
+        end
+
+        # Remove non-essential files
+        exts = %w[*.md *.rdoc *.txt *.c *.h *.o Makefile *.log CHANGELOG* HISTORY* LICENSE* README* .gitignore .travis.yml .rubocop.yml Rakefile]
+        exts.each do |pattern|
+          Dir.glob(File.join(vendor_dir, "**", pattern)).each do |f|
+            File.delete(f) if File.file?(f)
+          end
+        end
+
+        # Strip debug symbols from native extensions
+        Dir.glob(File.join(vendor_dir, '**/*.so')).each do |so_file|
+          system('strip', '--strip-debug', so_file, err: File::NULL, out: File::NULL)
+        end
+      end
+
+      def create_zip(build_dir)
+        zip_file = File.join(Dir.tmpdir, "belt-lambda-#{@env}-#{Time.now.to_i}.zip")
+
+        Dir.chdir(build_dir) do
+          output, status = Open3.capture2e('zip', '-qr', zip_file, '.')
+          unless status.success?
+            puts output
+            abort "\n✗ Failed to create ZIP"
+          end
+        end
+
+        size_mb = (File.size(zip_file) / 1024.0 / 1024.0).round(1)
+        puts "    🗜️  Package: #{size_mb}MB"
+        zip_file
+      end
+
+      def deploy_to_lambda(function_name, zip_file)
+        _output, status = Open3.capture2(
+          'aws', 'lambda', 'update-function-code',
+          '--function-name', function_name,
+          '--zip-file', "fileb://#{zip_file}",
+          '--output', 'json'
+        )
+
+        File.delete(zip_file) if File.exist?(zip_file)
+
+        unless status.success?
+          abort "\n✗ Failed to update Lambda function code.\n" \
+                "  Function: #{function_name}\n" \
+                "  Check that the function exists and you have permissions."
+        end
+
+        # Wait for update to complete
+        print '    Waiting for Lambda to be ready...'
+        30.times do
+          sleep 1
+          state_output, = Open3.capture2(
+            'aws', 'lambda', 'get-function',
+            '--function-name', function_name,
+            '--query', 'Configuration.LastUpdateStatus',
+            '--output', 'text'
+          )
+          case state_output.strip
+          when 'Successful'
+            puts ' ✅'
+            return
+          when 'Failed'
+            puts ' ✗'
+            abort '    Lambda update failed. Check CloudWatch logs.'
+          end
+          print '.'
+        end
+        puts ' (timed out waiting, but code was pushed)'
+      end
+
       def run_init
         puts '━━━ terraform init ━━━'
         success = system('terraform', 'init')
@@ -166,6 +482,18 @@ module Belt
         File.delete('tfplan') if File.exist?('tfplan')
       end
 
+      def deploy_frontend_if_exists
+        frontend_dir = File.join(@project_root, 'frontend')
+        return unless Dir.exist?(frontend_dir) && File.exist?(File.join(frontend_dir, 'package.json'))
+
+        puts "\n━━━ frontend deploy ━━━"
+        require_relative 'frontend_deploy_command'
+        Belt::CLI::FrontendDeployCommand.new(@env).run
+      rescue StandardError => e
+        puts "\n  ⚠ Frontend deploy failed: #{e.message}"
+        puts "    Run `belt deploy frontend #{@env}` manually to retry."
+      end
+
       def print_outputs(env_dir)
         Dir.chdir(env_dir) do
           output = `terraform output 2>/dev/null`.strip