belt 0.3.4 → 0.3.6

data/lib/belt/cli/frontend_deploy_command.rb

@@ -5,6 +5,7 @@ require 'open3'
 require_relative 'app_detection'
 require_relative 'env_resolver'
 require_relative 'frontend_env_map'
+require_relative 'frontend_registry'
 
 module Belt
   module CLI
@@ -12,12 +13,16 @@ module Belt
       include AppDetection
 
       def self.run(args)
+        frontend_name = FrontendRegistry.extract_flag!(args, '--frontend')
         env = EnvResolver.resolve(args)
 
         if env.nil?
-          puts 'Usage: belt deploy frontend <environment>'
-          puts "\nBuilds the frontend app and deploys to S3 + invalidates CloudFront."
+          puts 'Usage: belt deploy frontend <environment> [--frontend NAME]'
+          puts "\nBuilds frontend app(s) and deploys to S3 + invalidates CloudFront."
           puts 'You can also set BELT_ENV to skip the environment argument.'
+          puts "\nWith multiple frontends (config/frontends.yml):"
+          puts '  belt deploy frontend wups                  # deploy all'
+          puts '  belt deploy frontend wups --frontend ops   # deploy one'
           puts "\nExamples:"
           puts '  belt deploy frontend wups'
           puts '  belt deploy frontend dev01'
@@ -25,65 +30,101 @@ module Belt
           exit 1
         end
 
-        new(env).run
+        leftover = args.reject { |a| a.start_with?('-') }
+        frontend_name ||= leftover.shift
+
+        if frontend_name
+          frontend = FrontendRegistry.new.resolve!(frontend_name)
+          new(env, frontend: frontend).run
+        else
+          deploy_all(env)
+        end
+      end
+
+      def self.deploy_all(env)
+        frontends = FrontendRegistry.new.existing
+        abort FrontendRegistry.new.empty_message if frontends.empty?
+
+        frontends.each_with_index do |frontend, index|
+          puts if index.positive?
+          new(env, frontend: frontend).run
+        end
       end
 
-      def initialize(env)
+      def initialize(env, frontend: nil)
         @env = env
         @app_name = detect_app_name
         @env_dir = "infrastructure/#{@env}"
+        @frontend = frontend || FrontendRegistry.new.resolve!
       end
 
       def run
         validate!
+        puts "━━━ #{@frontend.label} (#{@frontend.path}/) ━━━"
         build_frontend
         sync_to_s3
         invalidate_cloudfront
         url = fetch_frontend_url
-        puts "\n✅ Frontend deployed to #{@env}!"
+        puts "\n✅ #{@frontend.label.capitalize} deployed to #{@env}!"
         puts "   #{url}" if url
       end
 
       private
 
       def validate!
-        unless Dir.exist?('frontend')
-          abort 'Error: No frontend/ directory found. Run `belt generate frontend react` first.'
+        unless Dir.exist?(@frontend.path)
+          abort "Error: No #{@frontend.path}/ directory found. " \
+                'Run `belt generate frontend react --name ' \
+                "#{@frontend.name} --path #{@frontend.path}` first."
         end
-        return if File.exist?('frontend/package.json')
+        return if File.exist?(@frontend.package_json)
 
-        abort 'Error: frontend/package.json not found.'
+        abort "Error: #{@frontend.package_json} not found."
       end
 
       def build_frontend
         puts '📦 Installing dependencies...'
-        install_cmd = File.exist?('frontend/package-lock.json') ? %w[npm ci] : %w[npm install]
-        run!(*install_cmd, chdir: 'frontend')
+        install_cmd = File.exist?(File.join(@frontend.path, 'package-lock.json')) ? %w[npm ci] : %w[npm install]
+        run!(*install_cmd, chdir: @frontend.path)
 
-        puts '🏗️  Building frontend...'
+        puts "🏗️  Building #{@frontend.label}..."
         env = frontend_build_env
         puts "   Injecting env: #{env.keys.sort.join(', ')}" if env.any?
-        run!(env, 'npm', 'run', 'build', chdir: 'frontend')
+        run!(env, 'npm', 'run', 'build', chdir: @frontend.path)
       end
 
-      # Resolve build env from frontend/env.yml map (or default VITE_API_URL ← api_url).
       def frontend_build_env
-        FrontendEnvMap.new(@env, env_dir: @env_dir).process_env
+        FrontendEnvMap.new(
+          @env,
+          env_dir: @env_dir,
+          frontend_path: @frontend.path
+        ).process_env
       end
 
       def sync_to_s3
         bucket = fetch_bucket_name
         abort "Error: Could not determine S3 bucket. Run `belt apply #{@env}` first." unless bucket
 
+        dist = @frontend.dist_dir
+        unless Dir.exist?(dist)
+          abort "Error: Build output not found at #{dist}/. " \
+                'Set `dist:` in config/frontends.yml if the app uses a non-default outDir.'
+        end
+
         puts "☁️  Deploying to S3... (#{bucket})"
 
+        dist_prefix = dist.end_with?('/') ? dist : "#{dist}/"
+
         # Hashed assets get immutable cache headers
-        run!('aws', 's3', 'sync', 'frontend/dist/', "s3://#{bucket}", '--delete',
+        run!('aws', 's3', 'sync', dist_prefix, "s3://#{bucket}", '--delete',
              '--size-only', '--cache-control', 'public, max-age=31536000, immutable',
              '--exclude', 'index.html')
 
+        index = File.join(dist, 'index.html')
+        abort "Error: #{index} not found after build." unless File.exist?(index)
+
         # index.html always revalidates
-        run!('aws', 's3', 'cp', 'frontend/dist/index.html', "s3://#{bucket}/index.html",
+        run!('aws', 's3', 'cp', index, "s3://#{bucket}/index.html",
              '--cache-control', 'no-cache')
       end
 
@@ -101,23 +142,71 @@ module Belt
       end
 
       def fetch_bucket_name
-        fetch_tf_output('frontend_bucket_name')
+        fetch_tf_output(@frontend.bucket_output)
       end
 
       def fetch_distribution_id
-        fetch_tf_output('frontend_distribution_id')
+        if probe_distribution_output?
+          id = fetch_tf_output(@frontend.distribution_output)
+          return id if id
+        end
+
+        domain = fetch_tf_output(@frontend.cloudfront_domain_output) if @frontend.cloudfront_domain_output
+        domain ||= domain_from_url(fetch_frontend_url)
+        lookup_distribution_id(domain)
+      end
+
+      # Belt-generated terraform exports `{name}_frontend_distribution_id`.
+      # Stowzilla-style configs only export a CloudFront domain — skip the
+      # inferred ID output so terraform doesn't print "output not found".
+      def probe_distribution_output?
+        @frontend.distribution_output_explicit? || @frontend.cloudfront_domain_output.to_s.empty?
       end
 
       def fetch_frontend_url
-        fetch_tf_output('frontend_url')
+        fetch_tf_output(@frontend.url_output)
+      end
+
+      def domain_from_url(url)
+        return nil if url.nil? || url.empty?
+
+        url.sub(%r{\Ahttps?://}i, '').split('/').first
+      end
+
+      # Stowzilla-style fallback: terraform may export a CloudFront domain
+      # instead of a distribution ID.
+      def lookup_distribution_id(domain)
+        return nil if domain.nil? || domain.empty?
+
+        query = "DistributionList.Items[?DomainName=='#{domain}'].Id"
+        output, status = Open3.capture2(
+          'aws', 'cloudfront', 'list-distributions',
+          '--query', query, '--output', 'text',
+          err: File::NULL
+        )
+        return nil unless status.success?
+
+        value = output.strip
+        value.empty? || value == 'None' ? nil : value.split(/\s+/).first
+      rescue Errno::ENOENT
+        nil
       end
 
       def fetch_tf_output(name)
-        output, status = Open3.capture2('terraform', 'output', '-raw', name, chdir: @env_dir)
+        return nil if name.nil? || name.to_s.empty?
+        return nil unless Dir.exist?(@env_dir)
+
+        output, status = Open3.capture2(
+          'terraform', 'output', '-raw', name,
+          chdir: @env_dir,
+          err: File::NULL
+        )
         return nil unless status.success?
 
         value = output.strip
         value.empty? || value == 'null' ? nil : value
+      rescue Errno::ENOENT
+        nil
       end
 
       def run!(*args, **)

data/lib/belt/cli/frontend_env_command.rb

@@ -3,14 +3,15 @@
 require_relative 'app_detection'
 require_relative 'env_resolver'
 require_relative 'frontend_env_map'
+require_relative 'frontend_registry'
 
 module Belt
   module CLI
-    # belt frontend env <environment>
+    # belt frontend env <environment> [--frontend NAME]
+    # belt frontend list
     #
-    # Smart-merges terraform outputs into frontend/.env using the declarative map
-    # (frontend/env.yml or .belt/frontend_env.yml). Only mapped keys are written;
-    # custom local keys are preserved.
+    # Smart-merges terraform outputs into <frontend>/.env using the declarative map
+    # (<frontend>/env.yml or .belt/frontend_env.yml for the default frontend).
     class FrontendEnvCommand
       include AppDetection
 
@@ -20,6 +21,8 @@ module Belt
         case subcommand
         when 'env'
           run_env(args)
+        when 'list', 'ls'
+          run_list
         when nil, '-h', '--help', 'help'
           puts usage
           exit(subcommand.nil? ? 1 : 0)
@@ -29,22 +32,51 @@ module Belt
         end
       end
 
+      def self.run_list
+        registry = FrontendRegistry.new
+        if registry.empty?
+          puts 'No frontends configured.'
+          puts 'Run `belt generate frontend react` or add config/frontends.yml.'
+          return
+        end
+
+        puts 'Frontends:'
+        registry.all.each do |fe|
+          marker = fe.default? ? '  (default)' : ''
+          status = fe.exists? ? '' : '  missing'
+          puts "  #{fe.name.ljust(16)} #{fe.path}/#{marker}#{status}"
+        end
+      end
+
       def self.run_env(args)
+        frontend_name = FrontendRegistry.extract_flag!(args, '--frontend')
         env = EnvResolver.resolve(args)
 
         if env.nil?
-          puts 'Usage: belt frontend env <environment>'
-          puts "\nWrites frontend/.env from terraform outputs using the env map."
+          puts 'Usage: belt frontend env <environment> [--frontend NAME]'
+          puts "\nWrites <frontend>/.env from terraform outputs using the env map."
           puts 'You can also set BELT_ENV to skip the environment argument.'
-          puts "\nMap file (optional): frontend/env.{yml,yaml} or .belt/frontend_env.{yml,yaml}"
+          puts "\nMap file (optional): <frontend>/env.{yml,yaml} or .belt/frontend_env.{yml,yaml}"
           puts 'Default without map: VITE_API_URL ← api_url'
           puts "\nExamples:"
           puts '  belt frontend env dev'
+          puts '  belt frontend env dev --frontend ops'
           puts '  BELT_ENV=dev belt frontend env'
           exit 1
         end
 
-        new(env).run
+        leftover = args.reject { |a| a.start_with?('-') }
+        frontend_name ||= leftover.shift
+
+        if frontend_name
+          frontend = FrontendRegistry.new.resolve!(frontend_name)
+          new(env, frontend: frontend).run
+        else
+          frontends = FrontendRegistry.new.all
+          abort FrontendRegistry.new.empty_message if frontends.empty?
+
+          frontends.each { |fe| new(env, frontend: fe).run }
+        end
       end
 
       def self.usage
@@ -52,12 +84,15 @@ module Belt
           Frontend helpers.
 
           Usage:
-            belt frontend env <environment>   Write frontend/.env from terraform outputs
+            belt frontend env <environment> [--frontend NAME]
+            belt frontend list
             belt frontend --help
 
-          Env map (optional):
-            frontend/env.yml
-            .belt/frontend_env.yml
+          Env map (optional, per frontend):
+            <frontend>/env.yml
+            .belt/frontend_env.yml   (default `frontend/` only)
+
+          Multiple frontends: config/frontends.yml (see `belt explain frontend`).
 
           Example map:
             VITE_API_URL: api_url
@@ -73,27 +108,29 @@ module Belt
         USAGE
       end
 
-      def initialize(env)
+      def initialize(env, frontend: nil)
         @env = env
         @app_name = detect_app_name
         @env_dir = "infrastructure/#{@env}"
+        @frontend = frontend || FrontendRegistry.new.resolve!
       end
 
       def run
-        unless Dir.exist?('frontend')
-          abort 'Error: No frontend/ directory found. Run `belt generate frontend react` first.'
+        unless Dir.exist?(@frontend.path)
+          abort "Error: No #{@frontend.path}/ directory found. Run `belt generate frontend react` first."
         end
 
         unless Dir.exist?(@env_dir)
           abort "Error: infrastructure/#{@env} not found. Run `belt generate environment #{@env}` first."
         end
 
-        map = FrontendEnvMap.new(@env, env_dir: @env_dir)
+        map = FrontendEnvMap.new(@env, env_dir: @env_dir, frontend_path: @frontend.path)
 
+        prefix = @frontend.name == 'frontend' ? '' : "[#{@frontend.name}] "
         if map.using_default_map?
-          puts '📋 No frontend/env.yml found — using default map (VITE_API_URL ← api_url)'
+          puts "📋 #{prefix}No #{@frontend.path}/env.yml found — using default map (VITE_API_URL ← api_url)"
         else
-          puts "📋 Loading env map from #{map.map_path}"
+          puts "📋 #{prefix}Loading env map from #{map.map_path}"
         end
 
         result = map.write_dotenv!

data/lib/belt/cli/frontend_env_map.rb

@@ -9,8 +9,10 @@ module Belt
     # Resolves frontend env vars from a declarative map (env name → terraform output).
     #
     # Map file (optional), first match wins:
-    #   frontend/env.yml
-    #   .belt/frontend_env.yml
+    #   <frontend-path>/env.yml
+    #   <frontend-path>/env.yaml
+    #   .belt/frontend_env.yml          (only for the default `frontend/` dir)
+    #   .belt/frontend_env.yaml
     #
     # Example:
     #   VITE_API_URL: api_url
@@ -30,18 +32,33 @@ module Belt
 
       DOTENV_PATH = File.join('frontend', '.env')
 
-      attr_reader :env_name, :env_dir, :map_path, :map
+      attr_reader :env_name, :env_dir, :map_path, :map, :frontend_path
 
-      def initialize(env_name, env_dir: nil, map_path: nil)
+      def initialize(env_name, env_dir: nil, map_path: nil, frontend_path: 'frontend')
         @env_name = env_name
         @env_dir = env_dir || File.join('infrastructure', env_name)
-        @map_path = map_path || self.class.find_map_path
+        @frontend_path = frontend_path
+        @map_path = map_path || self.class.find_map_path(frontend_path)
         @map = load_map
         @tf_cache = {}
       end
 
-      def self.find_map_path
-        MAP_CANDIDATES.find { |path| File.file?(path) }
+      def self.find_map_path(dir = 'frontend')
+        candidates_for(dir).find { |path| File.file?(path) }
+      end
+
+      def self.candidates_for(dir)
+        list = [
+          File.join(dir, 'env.yml'),
+          File.join(dir, 'env.yaml')
+        ]
+        if dir == 'frontend'
+          list += [
+            File.join('.belt', 'frontend_env.yml'),
+            File.join('.belt', 'frontend_env.yaml')
+          ]
+        end
+        list
       end
 
       # Hash of env_var => value suitable for process env (npm run build / vite).
@@ -54,11 +71,12 @@ module Belt
         resolved
       end
 
-      # Smart-merge mapped keys into frontend/.env.
+      # Smart-merge mapped keys into <frontend>/.env.
       # - Only overwrites keys present in the map
       # - Preserves unknown keys, comments, and blank lines
       # - Missing TF output → warn, do not clobber an existing value
-      def write_dotenv!(path: DOTENV_PATH)
+      def write_dotenv!(path: nil)
+        path ||= File.join(@frontend_path, '.env')
         FileUtils.mkdir_p(File.dirname(path))
 
         existing_lines = File.file?(path) ? File.readlines(path, chomp: true) : []