openclacky 0.7.0 → 0.7.2

data/lib/clacky/default_skills/deploy/scripts/rails_deploy.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+require_relative '../tools/list_services'
+require_relative '../tools/report_deploy_status'
+require_relative '../tools/execute_deployment'
+require_relative '../tools/set_deploy_variables'
+require_relative '../tools/fetch_runtime_logs'
+require_relative '../tools/check_health'
+
+module Clacky
+  module DeployTemplates
+    # Rails deployment template - Fixed 8-step deployment process
+    # No AI decision-making, pure automation
+    class RailsDeploy
+      # Execute the Rails deployment workflow
+      #
+      # @return [Hash] Deployment result
+      def self.execute
+        # CRITICAL: Check environment requirements
+        unless environment_valid?
+          return {
+            success: false,
+            error: "Railway deployment is only available in the Clacky cloud environment with Rails template projects.",
+            details: environment_check_details
+          }
+        end
+
+        puts "\n" + "="*60
+        puts "🚂 Rails Deployment Template (8-Step Process)"
+        puts "="*60 + "\n"
+
+        # Step 1: List services
+        step1_result = step1_list_services
+        return step1_result unless step1_result[:success]
+        
+        services = step1_result[:services]
+        main_service = step1_result[:main_service]
+        db_service = step1_result[:db_service]
+
+        # Step 2: Check first deployment
+        step2_result = step2_check_first_deployment(main_service)
+        return step2_result unless step2_result[:success]
+        
+        is_first = step2_result[:is_first_deployment]
+
+        # Step 3: Set Rails environment variables
+        step3_result = step3_set_rails_variables(main_service, db_service, is_first)
+        return step3_result unless step3_result[:success]
+
+        # Step 4: Execute deployment
+        step4_result = step4_execute_deployment(main_service)
+        return step4_result unless step4_result[:success]
+
+        # Step 5: Run database migrations
+        step5_result = step5_run_migrations(main_service)
+        return step5_result unless step5_result[:success]
+
+        # Step 6: Run database seeds (first deployment only)
+        if is_first
+          step6_result = step6_run_seeds(main_service)
+          return step6_result unless step6_result[:success]
+        else
+          puts "\n[Step 6] Skipping database seeds (not first deployment)\n"
+        end
+
+        # Step 7: Health check
+        step7_result = step7_health_check(main_service)
+        return step7_result unless step7_result[:success]
+
+        # Step 8: Report success
+        step8_report_success(main_service)
+      end
+
+      # Check if environment is valid for deployment
+      #
+      # @return [Boolean] true if both required environment variables are "true"
+      def self.environment_valid?
+        ENV['IS_RAILS_TEMPLATE'] == 'true' && ENV['IS_CLACKY_CDE'] == 'true'
+      end
+
+      # Get environment check details for error reporting
+      #
+      # @return [Hash] Details about environment check
+      def self.environment_check_details
+        {
+          is_rails_template: ENV['IS_RAILS_TEMPLATE'],
+          is_clacky_cde: ENV['IS_CLACKY_CDE'],
+          required: {
+            is_rails_template: 'true',
+            is_clacky_cde: 'true'
+          }
+        }
+      end
+
+      # Step 1: List Railway services
+      def self.step1_list_services
+        puts "\n[Step 1] Listing Railway services..."
+        DeployTools::ReportDeployStatus.execute(
+          status: 'analyzing',
+          message: 'Listing Railway services'
+        )
+
+        result = DeployTools::ListServices.execute
+        
+        unless result[:success]
+          return {
+            success: false,
+            error: "Failed to list services",
+            details: result
+          }
+        end
+
+        services = result[:services]
+        
+        # Find main web service
+        main_service = services.find { |s| s['type'] == 'web' || s['type'] == 'service' }
+        
+        if main_service.nil?
+          return {
+            success: false,
+            error: "No web service found",
+            details: "Please create a web service in Railway first"
+          }
+        end
+
+        # Find database service
+        db_service = services.find { |s| s['type'] == 'postgres' || s['type'] == 'mysql' }
+
+        puts "✅ Found #{services.length} service(s)"
+        puts "   Main service: #{main_service['name']}"
+        puts "   Database: #{db_service ? db_service['name'] : 'None'}"
+
+        {
+          success: true,
+          services: services,
+          main_service: main_service,
+          db_service: db_service
+        }
+      end
+
+      # Step 2: Check if this is first deployment
+      def self.step2_check_first_deployment(main_service)
+        puts "\n[Step 2] Checking deployment history..."
+
+        deployments = main_service['deployments'] || []
+        is_first = deployments.empty?
+
+        if is_first
+          puts "📦 This is the FIRST deployment"
+        else
+          puts "📦 This is a SUBSEQUENT deployment (#{deployments.length} previous deployment(s))"
+        end
+
+        {
+          success: true,
+          is_first_deployment: is_first,
+          previous_deployments: deployments.length
+        }
+      end
+
+      # Step 3: Set Rails environment variables
+      def self.step3_set_rails_variables(main_service, db_service, is_first)
+        puts "\n[Step 3] Setting Rails environment variables..."
+        DeployTools::ReportDeployStatus.execute(
+          status: 'analyzing',
+          message: 'Configuring Rails environment variables'
+        )
+
+        service_name = main_service['name']
+        
+        # Build simple variables
+        variables = {
+          'RAILS_ENV' => 'production',
+          'RAILS_SERVE_STATIC_FILES' => 'true',
+          'RAILS_LOG_TO_STDOUT' => 'true'
+        }
+
+        # Get or prompt for SECRET_KEY_BASE
+        secret_key_base = ENV['SECRET_KEY_BASE']
+        if secret_key_base.nil? || secret_key_base.empty?
+          puts "⚠️  SECRET_KEY_BASE not found. Please generate one:"
+          puts "   Run: rails secret"
+          print "Enter SECRET_KEY_BASE: "
+          secret_key_base = $stdin.gets.chomp
+        end
+        variables['SECRET_KEY_BASE'] = secret_key_base
+
+        # Build reference variables
+        ref_variables = {}
+        if db_service
+          ref_variables['DATABASE_URL'] = "#{db_service['name']}.DATABASE_URL"
+        end
+
+        # Set variables
+        result = DeployTools::SetDeployVariables.execute(
+          service_name: service_name,
+          variables: variables,
+          ref_variables: ref_variables
+        )
+
+        unless result[:success]
+          return {
+            success: false,
+            error: "Failed to set environment variables",
+            details: result
+          }
+        end
+
+        puts "✅ Set #{result[:set_variables].length} variable(s)"
+        if result[:skipped_variables].any?
+          puts "⚠️  Skipped #{result[:skipped_variables].length} protected variable(s)"
+        end
+
+        {
+          success: true,
+          set_count: result[:set_variables].length
+        }
+      end
+
+      # Step 4: Execute deployment
+      def self.step4_execute_deployment(main_service)
+        puts "\n[Step 4] Executing deployment..."
+        DeployTools::ReportDeployStatus.execute(
+          status: 'deploying',
+          message: 'Starting deployment to Railway'
+        )
+
+        service_name = main_service['name']
+        result = DeployTools::ExecuteDeployment.execute(service_name: service_name)
+
+        unless result[:success]
+          # Fetch logs for debugging
+          puts "\n❌ Deployment failed. Fetching logs..."
+          log_result = DeployTools::FetchRuntimeLogs.execute(
+            service_name: service_name,
+            lines: 100
+          )
+          
+          if log_result[:success]
+            puts "\n📋 Last 100 lines of logs:"
+            puts log_result[:logs]
+          end
+
+          return {
+            success: false,
+            error: "Deployment failed",
+            details: result
+          }
+        end
+
+        puts "✅ Deployment completed in #{result[:elapsed].round(1)}s"
+
+        {
+          success: true,
+          elapsed: result[:elapsed]
+        }
+      end
+
+      # Step 5: Run database migrations
+      def self.step5_run_migrations(main_service)
+        puts "\n[Step 5] Running database migrations..."
+
+        service_name = main_service['name']
+        command = "clackycli run -s '#{service_name}' rake db:migrate"
+        
+        puts "Running: rake db:migrate"
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code != 0
+          return {
+            success: false,
+            error: "Database migration failed",
+            details: output
+          }
+        end
+
+        puts "✅ Database migrations completed"
+        puts output if output && !output.empty?
+
+        {
+          success: true
+        }
+      end
+
+      # Step 6: Run database seeds
+      def self.step6_run_seeds(main_service)
+        puts "\n[Step 6] Running database seeds..."
+
+        service_name = main_service['name']
+        command = "clackycli run -s '#{service_name}' rake db:seed"
+        
+        puts "Running: rake db:seed"
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code != 0
+          puts "⚠️  Warning: Database seeding failed (this may be expected)"
+          puts output if output && !output.empty?
+        else
+          puts "✅ Database seeding completed"
+          puts output if output && !output.empty?
+        end
+
+        # Don't fail deployment if seeding fails
+        {
+          success: true
+        }
+      end
+
+      # Step 7: Health check
+      def self.step7_health_check(main_service)
+        puts "\n[Step 7] Performing health check..."
+        DeployTools::ReportDeployStatus.execute(
+          status: 'checking',
+          message: 'Verifying application health'
+        )
+
+        public_url = main_service['public_url']
+        
+        if public_url.nil? || public_url.empty?
+          puts "⚠️  Warning: No public URL found. Skipping health check."
+          return { success: true }
+        end
+
+        # Wait a bit for service to be fully ready
+        puts "⏳ Waiting 10 seconds for service to be ready..."
+        sleep 10
+
+        result = DeployTools::CheckHealth.execute(
+          url: public_url,
+          path: '/',
+          timeout: 30
+        )
+
+        unless result[:success]
+          puts "⚠️  Warning: Health check failed (service may still be starting)"
+          puts "   Error: #{result[:error]}"
+          puts "   You can manually check: #{public_url}"
+          # Don't fail deployment on health check failure
+        else
+          puts "✅ Health check passed (#{result[:status_code]} - #{result[:elapsed]}s)"
+        end
+
+        {
+          success: true,
+          health_check_result: result
+        }
+      end
+
+      # Step 8: Report success
+      def self.step8_report_success(main_service)
+        puts "\n[Step 8] Deployment completed successfully! 🎉"
+        
+        public_url = main_service['public_url']
+        
+        DeployTools::ReportDeployStatus.execute(
+          status: 'success',
+          message: "Rails app deployed successfully"
+        )
+
+        puts "\n" + "="*60
+        puts "✅ DEPLOYMENT SUCCESSFUL"
+        puts "="*60
+        puts "Service: #{main_service['name']}"
+        puts "URL: #{public_url || 'Not available yet'}" 
+        puts "="*60 + "\n"
+
+        {
+          success: true,
+          service: main_service['name'],
+          url: public_url
+        }
+      end
+    end
+  end
+end
+
+# Run deployment if executed directly
+if __FILE__ == $0
+  result = Clacky::DeployTemplates::RailsDeploy.execute
+  exit(result[:success] ? 0 : 1)
+end

data/lib/clacky/default_skills/deploy/tools/check_health.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Clacky
+  module DeployTools
+    # Perform HTTP health check on deployed application
+    class CheckHealth
+      DEFAULT_PATH = '/'
+      DEFAULT_TIMEOUT = 30
+      MAX_TIMEOUT = 120
+
+      # Perform health check
+      #
+      # @param url [String] Optional URL (defaults to RAILWAY_PUBLIC_DOMAIN env var)
+      # @param path [String] Health check path (default: "/")
+      # @param timeout [Integer] Request timeout in seconds (default: 30)
+      # @return [Hash] Result of health check
+      def self.execute(url: nil, path: DEFAULT_PATH, timeout: DEFAULT_TIMEOUT)
+        # Get URL from parameter or environment
+        target_url = url || ENV['RAILWAY_PUBLIC_DOMAIN']
+        
+        if target_url.nil? || target_url.empty?
+          return {
+            error: "No URL provided",
+            details: "Please provide a URL or set RAILWAY_PUBLIC_DOMAIN environment variable"
+          }
+        end
+
+        # Ensure URL has protocol
+        target_url = "https://#{target_url}" unless target_url.start_with?('http://', 'https://')
+
+        # Build full URL with path
+        full_url = "#{target_url.chomp('/')}#{path}"
+
+        # Validate timeout
+        timeout = timeout.to_i
+        if timeout <= 0 || timeout > MAX_TIMEOUT
+          timeout = DEFAULT_TIMEOUT
+        end
+
+        puts "🏥 Checking health: #{full_url} (timeout: #{timeout}s)"
+
+        begin
+          uri = URI.parse(full_url)
+          result = perform_request(uri, timeout)
+          
+          if result[:success]
+            puts "✅ Health check passed: #{result[:status_code]}"
+          else
+            puts "❌ Health check failed: #{result[:error]}"
+          end
+          
+          result.merge(url: full_url, path: path)
+        rescue URI::InvalidURIError => e
+          {
+            success: false,
+            error: "Invalid URL",
+            details: e.message,
+            url: full_url
+          }
+        end
+      end
+
+      # Perform HTTP request
+      #
+      # @param uri [URI] Target URI
+      # @param timeout [Integer] Timeout in seconds
+      # @return [Hash] Request result
+      def self.perform_request(uri, timeout)
+        start_time = Time.now
+        
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+        
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request['User-Agent'] = 'Clacky-Deploy-Health-Check/1.0'
+        
+        response = http.request(request)
+        elapsed = Time.now - start_time
+
+        {
+          success: response.is_a?(Net::HTTPSuccess),
+          status_code: response.code.to_i,
+          status_message: response.message,
+          elapsed: elapsed.round(2),
+          headers: response.to_hash,
+          body_preview: response.body&.slice(0, 500) # First 500 chars
+        }
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        {
+          success: false,
+          error: "Request timeout",
+          details: e.message,
+          elapsed: timeout
+        }
+      rescue SocketError => e
+        {
+          success: false,
+          error: "Network error",
+          details: e.message
+        }
+      rescue StandardError => e
+        {
+          success: false,
+          error: "Health check failed",
+          details: "#{e.class}: #{e.message}"
+        }
+      end
+    end
+  end
+end

data/lib/clacky/default_skills/deploy/tools/execute_deployment.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Clacky
+  module DeployTools
+    # Execute deployment and monitor until completion
+    class ExecuteDeployment
+      MAX_WAIT_TIME = 600 # 10 minutes
+      POLL_INTERVAL = 5   # 5 seconds
+
+      # Execute deployment for a service
+      #
+      # @param service_name [String] Service to deploy
+      # @return [Hash] Result of the deployment
+      def self.execute(service_name:)
+        if service_name.nil? || service_name.empty?
+          return {
+            error: "Service name is required",
+            details: "Please provide a valid service name"
+          }
+        end
+
+        puts "🚀 Starting deployment for service: #{service_name}"
+        
+        # Trigger deployment
+        command = "clackycli up -s #{shell_escape(service_name)} -d"
+        output = `#{command} 2>&1`
+        exit_code = $?.exitstatus
+
+        if exit_code != 0
+          return {
+            error: "Failed to trigger deployment",
+            details: output,
+            exit_code: exit_code,
+            service: service_name
+          }
+        end
+
+        puts "✅ Deployment triggered successfully"
+        puts "⏳ Monitoring deployment progress..."
+
+        # Monitor deployment status
+        result = monitor_deployment(service_name)
+        result[:service] = service_name
+        result
+      end
+
+      # Monitor deployment status until completion or timeout
+      #
+      # @param service_name [String] Service name
+      # @return [Hash] Deployment result
+      def self.monitor_deployment(service_name)
+        start_time = Time.now
+        last_status = nil
+
+        loop do
+          elapsed = Time.now - start_time
+          
+          if elapsed > MAX_WAIT_TIME
+            return {
+              success: false,
+              error: "Deployment timeout",
+              details: "Deployment exceeded maximum wait time of #{MAX_WAIT_TIME} seconds",
+              elapsed: elapsed
+            }
+          end
+
+          # Get deployment status
+          status = get_deployment_status(service_name)
+          
+          # Print status update if changed
+          if status[:current_status] != last_status
+            puts "📊 Status: #{status[:current_status]}"
+            last_status = status[:current_status]
+          end
+
+          # Check if deployment completed
+          if status[:completed]
+            if status[:success]
+              return {
+                success: true,
+                message: "Deployment completed successfully",
+                elapsed: elapsed,
+                final_status: status[:current_status]
+              }
+            else
+              return {
+                success: false,
+                error: "Deployment failed",
+                details: status[:error_message],
+                elapsed: elapsed,
+                final_status: status[:current_status]
+              }
+            end
+          end
+
+          # Wait before next poll
+          sleep POLL_INTERVAL
+        end
+      end
+
+      # Get current deployment status
+      #
+      # @param service_name [String] Service name
+      # @return [Hash] Status information
+      def self.get_deployment_status(service_name)
+        command = "clackycli service list --json"
+        output = `#{command} 2>&1`
+        
+        begin
+          services = JSON.parse(output)
+          service = services.find { |s| s['name'] == service_name }
+          
+          if service.nil?
+            return {
+              completed: true,
+              success: false,
+              error_message: "Service not found: #{service_name}"
+            }
+          end
+
+          # Get latest deployment
+          deployments = service['deployments'] || []
+          latest = deployments.first
+          
+          if latest.nil?
+            return {
+              completed: false,
+              current_status: 'waiting'
+            }
+          end
+
+          status = latest['status']
+          
+          case status
+          when 'SUCCESS', 'ACTIVE'
+            {
+              completed: true,
+              success: true,
+              current_status: status
+            }
+          when 'FAILED', 'CRASHED'
+            {
+              completed: true,
+              success: false,
+              current_status: status,
+              error_message: latest['error'] || 'Deployment failed'
+            }
+          else
+            {
+              completed: false,
+              current_status: status
+            }
+          end
+        rescue JSON::ParserError
+          {
+            completed: true,
+            success: false,
+            error_message: "Failed to parse deployment status"
+          }
+        end
+      end
+
+      # Escape shell arguments
+      #
+      # @param str [String] String to escape
+      # @return [String] Escaped string
+      def self.shell_escape(str)
+        "'#{str.gsub("'", "'\\\\''")}'"
+      end
+    end
+  end
+end