belt 0.1.4 → 0.1.6

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.jpg') || ''
+
+        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/jpeg;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/jpeg;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

data/lib/belt/controllers/welcome_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Belt
+  # Gem-embedded welcome controller that serves the default "it works!" page.
+  # Resolved via the ActionRouter's Belt:: namespace fallback when no app-defined
+  # WelcomeController exists. Gets replaced once the user defines their own root route.
+  class WelcomeController < BeltController::Base
+    skip_before_action :authenticate!
+
+    ASSETS_DIR = File.expand_path('../assets', __dir__)
+
+    def show
+      @title = ENV.fetch('WELCOME_TITLE', 'Welcome to Belt')
+      @subtitle = ENV.fetch('WELCOME_SUBTITLE', 'API Gateway → Lambda → DynamoDB — all connected.')
+      @css = welcome_css
+      @background_image = background_image_base64
+      @dynamodb_connected = dynamodb_connected?
+
+      render
+    end
+
+    private
+
+    def dynamodb_connected?
+      return false unless defined?(Aws::DynamoDB::Client)
+
+      client = Aws::DynamoDB::Client.new
+      client.list_tables(limit: 1)
+      true
+    rescue StandardError
+      false
+    end
+
+    def welcome_css
+      @welcome_css_content ||= File.read(File.join(ASSETS_DIR, 'welcome.css'))
+    end
+
+    def background_image_base64
+      @background_image_content ||= Base64.strict_encode64(
+        File.binread(File.join(ASSETS_DIR, 'belt-default.jpg'))
+      )
+    end
+  end
+end

data/lib/belt/rendering.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'cgi'
+
+module Belt
+  # Provides Rails-like ERB rendering for BeltController.
+  #
+  # Convention: templates live at `views/<controller_name>/<action>.html.erb`
+  # relative to the controller's gem or app directory.
+  #
+  # Usage:
+  #   class WelcomeController < BeltController::Base
+  #     def show
+  #       @title = "Hello"
+  #       render  # auto-resolves to views/welcome/show.html.erb
+  #     end
+  #   end
+  #
+  # Or explicit:
+  #   render template: "welcome/show"
+  #   render inline: "<h1><%= @title %></h1>"
+  #
+  module Rendering
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Override in subclasses to set a custom view path.
+      # Defaults to `views/` relative to the file that defines the controller.
+      def view_paths
+        @view_paths ||= []
+      end
+
+      def prepend_view_path(path)
+        view_paths.unshift(path)
+      end
+
+      def append_view_path(path)
+        view_paths << path
+      end
+    end
+
+    private
+
+    # Render an ERB template and return an html_response.
+    #
+    # Options:
+    #   render                         — auto-resolve from controller/action
+    #   render template: "ctrl/action" — explicit template path (no extension)
+    #   render inline: "<%= @x %>"     — render a string as ERB
+    #   render status: 201             — custom status code
+    #   render layout: false           — skip layout (default: no layout)
+    #
+    def render(options = {})
+      status = options.fetch(:status, 200)
+
+      html = if options.key?(:inline)
+               render_erb_string(options[:inline])
+             else
+               template_path = resolve_template_path(options[:template])
+               render_erb_file(template_path)
+             end
+
+      html_response(html, status)
+    end
+
+    def render_erb_string(source)
+      erb = ERB.new(source, trim_mode: '-')
+      erb.result(binding)
+    end
+
+    def render_erb_file(path)
+      raise Belt::TemplateNotFound, "Template not found: #{path}" unless File.exist?(path)
+
+      source = File.read(path)
+      erb = ERB.new(source, trim_mode: '-')
+      erb.filename = path
+      erb.result(binding)
+    end
+
+    # HTML-escape helper, available in templates as `h(value)`
+    def h(text)
+      CGI.escapeHTML(text.to_s)
+    end
+
+    def resolve_template_path(explicit_template = nil)
+      template_name = explicit_template || default_template_name
+      search_paths = build_view_search_paths
+
+      search_paths.each do |base|
+        full_path = File.join(base, "#{template_name}.html.erb")
+        return full_path if File.exist?(full_path)
+      end
+
+      # If nothing found, return the first candidate so the error message is useful
+      File.join(search_paths.first || '.', "#{template_name}.html.erb")
+    end
+
+    def default_template_name
+      # PostsController → posts, Belt::WelcomeController → welcome
+      controller = self.class.name.split('::').last
+                       .sub(/Controller$/, '')
+                       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                       .downcase
+      "#{controller}/#{action_name}"
+    end
+
+    def build_view_search_paths
+      paths = []
+
+      # 1. Class-level view paths (set by the controller or gem)
+      paths.concat(self.class.view_paths) if self.class.respond_to?(:view_paths)
+
+      # 2. Walk up the class hierarchy for inherited view paths
+      klass = self.class.superclass
+      while klass.respond_to?(:view_paths)
+        paths.concat(klass.view_paths)
+        klass = klass.superclass
+      end
+
+      # 3. App-level views (convention: lambda/views/ from Belt.root)
+      if defined?(Belt.root) && Belt.root
+        paths << File.join(Belt.root, 'lambda', 'views')
+        paths << File.join(Belt.root, 'views')
+      end
+
+      # 4. Gem-level fallback (views/ relative to this file — belt gem's own views)
+      paths << File.expand_path('views', __dir__)
+
+      paths.uniq
+    end
+  end
+end

data/lib/belt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
 end

data/lib/belt/views/welcome/show.html.erb

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title><%= h(@title) %></title>
+  <style><%= @css %></style>
+</head>
+<body>
+  <div class="hero">
+    <img src="data:image/jpeg;base64,<%= @background_image %>" alt="Belt" class="hero-bg" />
+    <div class="overlay">
+      <h1><%= h(@title) %></h1>
+      <p class="subtitle"><%= h(@subtitle) %></p>
+    </div>
+  </div>
+  <div class="container">
+    <div class="stack-check">
+      <div class="check-item check-pass">
+        <span class="icon">✓</span>
+        <span>API Gateway</span>
+      </div>
+      <div class="arrow">→</div>
+      <div class="check-item check-pass">
+        <span class="icon">✓</span>
+        <span>Lambda</span>
+      </div>
+      <div class="arrow">→</div>
+      <%- if @dynamodb_connected -%>
+      <div class="check-item check-pass">
+        <span class="icon">✓</span>
+        <span>DynamoDB</span>
+      </div>
+      <%- else -%>
+      <div class="check-item check-warn">
+        <span class="icon">⚠</span>
+        <span>DynamoDB</span>
+      </div>
+      <%- end -%>
+    </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: <code>belt deploy</code></li>
+        <li>This page will be replaced once you define your own root route.</li>
+      </ol>
+    </div>
+  </div>
+</body>
+</html>

data/lib/belt.rb

@@ -11,6 +11,7 @@ module Belt
   class AuthenticationError < StandardError; end
   class RecordNotFound < StandardError; end
   class ActionNotFound < StandardError; end
+  class TemplateNotFound < StandardError; end
 
   @controller_paths = []
 
@@ -55,3 +56,4 @@ module Belt
 end
 
 require_relative 'belt_controller/base'
+require_relative 'belt/controllers/welcome_controller'