belt 0.1.4 → 0.1.5

data/lib/belt/cli/new_command.rb

@@ -2,40 +2,76 @@
 
 require 'fileutils'
 require 'erb'
+require 'json'
+require 'open3'
+require_relative 'setup_command'
 
 module Belt
   module CLI
     class NewCommand
       TEMPLATE_DIR = File.expand_path('../../templates/new_app', __dir__)
+      DEFAULT_ENVIRONMENTS = %w[dev prod].freeze
 
       def self.run(args)
         app_name = nil
         frontend = nil
+        bucket = nil
+        environments = nil
 
-        args.each do |arg|
-          if arg.start_with?('--frontend')
-            frontend = if arg.include?('=')
-                         arg.split('=', 2).last
-                       else
-                         args[args.index(arg) + 1]
-                       end
-          elsif !arg.start_with?('-')
-            app_name ||= arg
+        i = 0
+        while i < args.length
+          arg = args[i]
+          case arg
+          when '--frontend'
+            if arg.include?('=')
+              frontend = arg.split('=', 2).last
+            else
+              i += 1
+              frontend = args[i]
+            end
+          when /^--frontend=/
+            frontend = arg.split('=', 2).last
+          when '--bucket', '--state-bucket'
+            i += 1
+            bucket = args[i]
+          when /^--bucket=/
+            bucket = arg.split('=', 2).last
+          when /^--state-bucket=/
+            bucket = arg.split('=', 2).last
+          when '--environments'
+            i += 1
+            environments = args[i]
+          when /^--environments=/
+            environments = arg.split('=', 2).last
+          else
+            app_name ||= arg unless arg.start_with?('-')
           end
+          i += 1
         end
 
         if app_name.nil? || app_name.empty?
-          puts 'Usage: belt new <app_name> [--frontend react|vue|svelte]'
+          puts 'Usage: belt new <app_name> [options]'
+          puts ''
+          puts 'Options:'
+          puts '  --frontend react|vue|svelte    Set up frontend framework'
+          puts '  --bucket BUCKET_NAME           S3 bucket for Terraform state'
+          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'
           exit 1
         end
 
-        new(app_name, frontend: frontend).generate
+        new(app_name, frontend: frontend, bucket: bucket, environments: environments).generate
       end
 
-      def initialize(app_name, frontend: nil)
+      def initialize(app_name, frontend: nil, bucket: nil, environments: nil)
         @app_name = app_name.gsub(/[^a-z0-9_-]/i, '_').downcase
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @frontend = frontend
+        @bucket = bucket
+        @environments = parse_environments(environments)
+        @resolved_bucket = nil
+        @state_setup_succeeded = false
       end
 
       def generate
@@ -47,19 +83,23 @@ module Belt
         puts "Creating new Belt application: #{@app_name}"
         create_structure
         generate_frontend if @frontend
+        generate_environments
         init_git
+        run_bundle_install
+        setup_state
         puts "\n✓ #{@app_name} created successfully!"
-        puts "\nNext steps:"
-        puts "  cd #{@app_name}"
-        puts '  bundle install'
-        puts '  cd frontend && npm install && npm run dev' if @frontend
-        puts '  # Define your models in infrastructure/schema.tf.rb'
-        puts '  # Define your routes in infrastructure/routes.tf.rb'
-        puts "  # Add controllers in lambda/controllers/#{@app_name}/"
+        print_next_steps
       end
 
       private
 
+      def parse_environments(env_string)
+        return DEFAULT_ENVIRONMENTS if env_string.nil? || env_string.empty?
+        return [] if env_string.downcase == 'none'
+
+        env_string.split(',').map(&:strip).reject(&:empty?)
+      end
+
       def create_structure
         directories.each { |dir| create_dir(dir) }
         files.each { |src, dest| create_file(src, dest) }
@@ -96,6 +136,84 @@ module Belt
         }
       end
 
+      def generate_environments
+        return if @environments.empty?
+
+        Dir.chdir(@app_name) do
+          @environments.each do |env_name|
+            Belt::CLI::EnvironmentCommand.new(env_name, quiet: true).generate
+          end
+        end
+      end
+
+      def setup_state
+        return if @environments.empty?
+
+        Dir.chdir(@app_name) do
+          # Resolve bucket name — include account ID + region if AWS credentials are available
+          if @bucket
+            @resolved_bucket = @bucket
+          elsif aws_configured?
+            region = detect_region
+            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state-#{@aws_account_id}-#{region}")
+          else
+            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state")
+          end
+
+          # Update backend.tf files with the resolved bucket name
+          @environments.each do |env_name|
+            backend_file = "infrastructure/#{env_name}/backend.tf"
+            next unless File.exist?(backend_file)
+
+            content = File.read(backend_file)
+            updated = content.gsub(/bucket\s*=\s*"[^"]+"/, "bucket  = \"#{@resolved_bucket}\"")
+            File.write(backend_file, updated) if updated != content
+          end
+
+          # Attempt to actually create the bucket if credentials are available
+          if @aws_account_id
+            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}"
+            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
+        end
+      end
+
+      def detect_region
+        Dir.glob('infrastructure/*/backend.tf').each do |f|
+          match = File.read(f).match(/region\s*=\s*"([^"]+)"/)
+          return match[1] if match
+        end
+        'us-east-1'
+      end
+
+      def aws_configured?
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        if status.success?
+          data = JSON.parse(output) rescue {}
+          @aws_account_id = data['Account']
+          true
+        else
+          @aws_error = output.strip
+          false
+        end
+      end
+
       def create_dir(dir)
         FileUtils.mkdir_p(dir)
         puts "  create  #{dir}/"
@@ -111,17 +229,42 @@ module Belt
       def init_git
         Dir.chdir(@app_name) do
           system('git', 'init', '--quiet')
-          system('git', 'add', '.')
-          system('git', 'commit', '-m', 'Initial commit', '--quiet')
         end
         puts "  init    #{@app_name}/.git/"
       end
 
+      def run_bundle_install
+        Dir.chdir(@app_name) do
+          puts "\n  Running bundle install..."
+          success = system('bundle', 'install', '--quiet')
+          if success
+            puts '  ✓ Bundle installed'
+          else
+            puts '  ⚠ bundle install failed — run it manually after resolving issues.'
+          end
+        end
+      end
+
       def generate_frontend
         Dir.chdir(@app_name) do
           Belt::CLI::FrontendCommand.new(@frontend).generate
         end
       end
+
+      def print_next_steps
+        puts "\nNext steps:"
+        puts "  cd #{@app_name}"
+        unless @state_setup_succeeded
+          puts '  # Configure AWS credentials (aws sso login / AWS_PROFILE)'
+          puts '  belt setup state              # Create the S3 state bucket'
+        end
+        puts '  belt deploy                   # Deploy to AWS'
+        puts '  belt server                   # Start local frontend server' if @frontend
+      end
+
+      def s3_safe_name(name)
+        name.to_s.downcase.tr('_', '-')
+      end
     end
   end
 end

data/lib/belt/cli/server_command.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require_relative 'app_detection'
+require_relative 'terraform_command'
+
+module Belt
+  module CLI
+    class ServerCommand
+      include AppDetection
+
+      DEFAULT_PORT = 3000
+
+      def self.run(args)
+        port = DEFAULT_PORT
+        open_browser = false
+
+        i = 0
+        while i < args.length
+          case args[i]
+          when '-p', '--port'
+            i += 1
+            port = args[i].to_i
+          when /^--port=/
+            port = args[i].split('=', 2).last.to_i
+          when '-o', '--open'
+            open_browser = true
+          when '-h', '--help'
+            puts help_text
+            exit 0
+          end
+          i += 1
+        end
+
+        new(port: port, open_browser: open_browser).run
+      end
+
+      def self.help_text
+        <<~HELP
+          Start a local development server for the frontend.
+
+          Usage: belt server [options]
+                 belt s [options]
+
+          Options:
+            -p, --port PORT    Port to serve on (default: #{DEFAULT_PORT})
+            -o, --open         Open browser after starting
+            -h, --help         Show this help
+
+          Behavior:
+            • If frontend/ exists → runs the frontend dev server (npm run dev)
+              Automatically sets VITE_API_URL from terraform outputs if deployed.
+            • If no frontend → serves the welcome page via a local HTTP server
+              After deploy, shows live API URL and deployment status.
+
+          Note: The backend is serverless (AWS Lambda). Use `belt deploy` to deploy
+          your backend to AWS. Local frontend development automatically points to
+          your deployed API via VITE_API_URL.
+
+          Examples:
+            belt server                 # Start on port #{DEFAULT_PORT}
+            belt s -p 4000             # Start on port 4000
+            belt s --open              # Start and open browser
+        HELP
+      end
+
+      def initialize(port:, open_browser: false)
+        @port = port
+        @open_browser = open_browser
+        @app_name = detect_app_name
+        @api_url = detect_api_url
+      end
+
+      def run
+        if Dir.exist?('frontend') && File.exist?('frontend/package.json')
+          run_frontend_dev_server
+        else
+          run_welcome_server
+        end
+      end
+
+      private
+
+      def run_frontend_dev_server
+        puts "🚀 Starting frontend dev server on port #{@port}..."
+        if @api_url
+          puts "   Backend API: #{@api_url}"
+        else
+          puts '   Backend is serverless — deploy with `belt deploy` to set up AWS resources.'
+        end
+        puts ''
+
+        open_browser_later if @open_browser
+
+        env = { 'PORT' => @port.to_s }
+        env['VITE_API_URL'] = @api_url if @api_url
+
+        # Prefer the dev script with the port flag for Vite-based setups
+        Dir.chdir('frontend') do
+          exec(env, 'npx', 'vite', '--port', @port.to_s)
+        end
+      end
+
+      def run_welcome_server
+        if @api_url
+          puts "🚀 Serving Belt welcome page on http://localhost:#{@port}"
+          puts "   Backend API: #{@api_url}"
+          puts ''
+          puts '   Tip: Run `belt generate frontend react` to scaffold a frontend app.'
+          puts ''
+        else
+          puts "🚀 Serving Belt welcome page on http://localhost:#{@port}"
+          puts '   No deployment detected — showing pre-deploy welcome page.'
+          puts '   Backend is serverless — deploy with `belt deploy` to set up AWS resources.'
+          puts ''
+          puts '   Tip: Run `belt generate frontend react` to scaffold a frontend app.'
+          puts ''
+        end
+
+        require 'webrick'
+
+        server = WEBrick::HTTPServer.new(Port: @port, Logger: WEBrick::Log.new('/dev/null'), AccessLog: [])
+
+        server.mount_proc '/' do |_req, res|
+          res['Content-Type'] = 'text/html; charset=utf-8'
+          res.body = welcome_html
+        end
+
+        open_browser_later if @open_browser
+
+        trap('INT') { server.shutdown }
+        trap('TERM') { server.shutdown }
+
+        server.start
+      end
+
+      def gem_assets_dir
+        @gem_assets_dir ||= File.expand_path('../assets', __dir__)
+      end
+
+      def welcome_html
+        title = ENV.fetch('WELCOME_TITLE', 'Welcome to Belt')
+        subtitle = ENV.fetch('WELCOME_SUBTITLE', 'Your app is ready. Deploy to see it live on AWS.')
+
+        css = load_asset('welcome.css') || ''
+        image_b64 = load_image_base64('belt-default.png') || ''
+
+        if @api_url
+          deployed_html(css: css, image_b64: image_b64)
+        else
+          pre_deploy_html(title: title, subtitle: subtitle, css: css, image_b64: image_b64)
+        end
+      end
+
+      def load_asset(filename)
+        path = File.join(gem_assets_dir, filename)
+        File.exist?(path) ? File.read(path) : nil
+      end
+
+      def load_image_base64(filename)
+        path = File.join(gem_assets_dir, filename)
+        File.exist?(path) ? Base64.strict_encode64(File.binread(path)) : nil
+      end
+
+      def deployed_html(css:, image_b64:)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>#{@app_name} — Deployed</title>
+            <style>#{css}</style>
+          </head>
+          <body>
+            <div class="hero">
+              <img src="data:image/png;base64,#{image_b64}" alt="Belt" class="hero-bg" />
+              <div class="overlay">
+                <h1>#{@app_name}</h1>
+                <p class="subtitle">Deployed and running on AWS</p>
+              </div>
+            </div>
+            <div class="container">
+              <div class="next-steps">
+                <h2>Next Steps</h2>
+                <ol>
+                  <li>View your live app: <a href="#{@api_url}">#{@api_url}</a> (#{@deploy_env || 'dev'})</li>
+                  <li>Generate a resource: <code>belt g resource post title:string body:text</code></li>
+                  <li>Set up a frontend: <code>belt generate frontend react</code></li>
+                </ol>
+              </div>
+            </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      def pre_deploy_html(title:, subtitle:, css:, image_b64:)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>#{title}</title>
+            <style>#{css}</style>
+          </head>
+          <body>
+            <div class="hero">
+              <img src="data:image/png;base64,#{image_b64}" alt="Belt" class="hero-bg" />
+              <div class="overlay">
+                <h1>#{title}</h1>
+                <p class="subtitle">#{subtitle}</p>
+              </div>
+            </div>
+            <div class="container">
+              <div class="info">
+                <p><strong>App:</strong> #{@app_name}</p>
+                <p><strong>Status:</strong> Not yet deployed</p>
+              </div>
+              <div class="next-steps">
+                <h2>Next Steps</h2>
+                <ol>
+                  <li>Generate a resource: <code>belt g resource post title:string body:text</code></li>
+                  <li>Deploy to AWS: <code>belt deploy</code></li>
+                  <li>Set up a frontend: <code>belt generate frontend react</code></li>
+                </ol>
+              </div>
+            </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      # Reads terraform outputs to find the deployed API URL.
+      # Checks all available environments, preferring BELT_ENV.
+      def detect_api_url
+        infra_dir = TerraformCommand.find_infrastructure_dir
+        return nil unless infra_dir
+
+        # Prefer BELT_ENV, then try each environment
+        envs = TerraformCommand.list_environments
+        preferred = ENV.fetch('BELT_ENV', nil)
+        envs.unshift(envs.delete(preferred)) if preferred && envs.include?(preferred)
+
+        envs.each do |env|
+          env_dir = File.join(infra_dir, env)
+          next unless Dir.exist?(env_dir)
+          next unless File.exist?(File.join(env_dir, '.terraform'))
+
+          url = read_api_url_from_outputs(env_dir)
+          if url
+            @deploy_env = env
+            return url
+          end
+        end
+
+        nil
+      end
+
+      def read_api_url_from_outputs(env_dir)
+        output = nil
+        Dir.chdir(env_dir) do
+          # Use Open3 to check exit status — terraform writes errors to stdout too
+          require 'open3'
+          output, status = Open3.capture2('terraform', 'output', '-json', err: File::NULL)
+          return nil unless status.success?
+        end
+        return nil if output.nil? || output.strip.empty?
+
+        data = JSON.parse(output.strip)
+
+        # api_url output is a map like { "app_name" => "https://..." }
+        if data['api_url'] && data['api_url']['value']
+          value = data['api_url']['value']
+          case value
+          when String
+            value
+          when Hash
+            # Take the first URL from the map
+            value.values.first
+          end
+        end
+      rescue JSON::ParserError, Errno::ENOENT
+        nil
+      end
+
+      def open_browser_later
+        Thread.new do
+          sleep 1.5
+          url = "http://localhost:#{@port}"
+          if RUBY_PLATFORM.include?('darwin')
+            system('open', url)
+          elsif RUBY_PLATFORM.include?('linux')
+            system('xdg-open', url, out: File::NULL, err: File::NULL)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/setup_command.rb

@@ -52,10 +52,18 @@ module Belt
 
       def run_state_setup
         unless aws_configured?
-          puts '✗ AWS credentials not configured. Set AWS_PROFILE or configure aws sso login.'
+          if @aws_error&.include?('ForbiddenException') || @aws_error&.include?('AccessDenied')
+            puts "✗ AWS credentials found but access denied — check your profile/role configuration."
+            puts "  #{@aws_error}"
+          else
+            puts '✗ AWS credentials not configured. Set AWS_PROFILE or configure aws sso login.'
+          end
           exit 1
         end
 
+        # Re-resolve bucket name with account ID suffix now that we have credentials
+        @bucket_name = resolve_bucket_name unless @custom_bucket
+
         @bucket_name = interactive_bucket_selection if @select_mode
         setup_or_verify_bucket
         apply_lifecycle(@bucket_name)
@@ -133,10 +141,14 @@ module Belt
       def resolve_bucket_name
         if @custom_bucket
           @custom_bucket
-        elsif @env_name
-          s3_safe_name("#{@app_name}-terraform-state-#{@env_name}")
         else
-          s3_safe_name("#{@app_name}-terraform-state")
+          base = if @env_name
+                   "#{@app_name}-terraform-state-#{@env_name}"
+                 else
+                   "#{@app_name}-terraform-state"
+                 end
+          base = "#{base}-#{@aws_account_id}-#{@region}" if @aws_account_id
+          s3_safe_name(base)
         end
       end
 
@@ -184,11 +196,33 @@ module Belt
       # --- AWS operations ---
 
       def aws_configured?
-        system('aws', 'sts', 'get-caller-identity', out: File::NULL, err: File::NULL)
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        if status.success?
+          data = JSON.parse(output) rescue {}
+          @aws_account_id = data['Account']
+          true
+        else
+          @aws_error = output.strip
+          false
+        end
+      end
+
+      def aws_account_id
+        @aws_account_id
       end
 
       def bucket_exists?(bucket)
-        system('aws', 's3api', 'head-bucket', '--bucket', bucket, err: File::NULL)
+        output, status = Open3.capture2e('aws', 's3api', 'head-bucket', '--bucket', bucket)
+        return true if status.success?
+
+        # 403 = bucket exists but owned by someone else; 404 = doesn't exist
+        if output.include?('403') || output.include?('Forbidden')
+          puts "\n✗ Bucket '#{bucket}' exists but is owned by a different AWS account."
+          puts '  S3 bucket names are globally unique. Choose a different name with --bucket.'
+          exit 1
+        end
+
+        false
       end
 
       def create_bucket(bucket)

data/lib/belt/cli.rb

@@ -11,6 +11,8 @@ require_relative 'cli/frontend_deploy_command'
 require_relative 'cli/views_command'
 require_relative 'cli/setup_command'
 require_relative 'cli/terraform_command'
+require_relative 'cli/deploy_command'
+require_relative 'cli/server_command'
 require_relative 'cli/routes_command'
 require_relative 'cli/tasks_command'
 require_relative 'cli/console_command'
@@ -24,15 +26,8 @@ module Belt
       %w[console c] => Belt::CLI::ConsoleCommand,
       %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
       'setup' => Belt::CLI::SetupCommand,
-      'deploy' => lambda { |args|
-        subcommand = args.shift
-        if subcommand == 'frontend'
-          Belt::CLI::FrontendDeployCommand.run(args)
-        else
-          puts 'Usage: belt deploy frontend <environment>'
-          exit 1
-        end
-      },
+      'deploy' => Belt::CLI::DeployCommand,
+      %w[server s] => Belt::CLI::ServerCommand,
       %w[version --version -v] => ->(_args) { puts "Belt #{Belt::VERSION}" }
     }.freeze
 
@@ -80,6 +75,10 @@ module Belt
           generate frontend <react|vue|svelte>        Scaffold a frontend app
           generate views <resource> [fields...]       Generate React pages for REST actions
           generate environment <name>                 Create a new environment
+          server                                      Start local dev server (frontend)
+          s                                           Alias for server
+          deploy [environment]                        Deploy to AWS (init → plan → apply)
+          deploy frontend <env>                       Build and deploy frontend to AWS
           routes [-g PATTERN] [-f json]               Show route definitions
           console                                     Start an interactive console (IRB)
           c                                           Alias for console
@@ -88,7 +87,6 @@ module Belt
           setup state                                 Create/select S3 state bucket
           setup tables <env>                          Generate DynamoDB tables from schema
           setup frontend <env>                        Generate S3 + CloudFront infrastructure
-          deploy frontend <env>                       Build and deploy frontend to AWS
           init [environment] <env>                    terraform init for environment
           plan [environment] <env>                    terraform plan for environment
           apply [environment] <env>                   terraform apply for environment
@@ -110,8 +108,11 @@ module Belt
           belt new blog --frontend react
           belt generate resource post title:string content:text status:string
           belt generate frontend react
-          belt setup frontend wups
+          belt server                   # Start local frontend server
+          belt deploy                   # Deploy dev to AWS
+          belt deploy prod --auto       # Deploy prod without confirmation
           belt deploy frontend wups
+          belt setup frontend wups
           belt apply wups
           belt tasks                    # list all rake tasks
           belt lambda:build_layer       # run a rake task directly