language-operator 0.1.61 → 0.1.62

data/lib/language_operator/agent/web_server.rb

@@ -3,6 +3,7 @@
 require 'rack'
 require 'rackup'
 require 'mcp'
+require_relative 'executor'
 
 module LanguageOperator
   module Agent
@@ -26,10 +27,13 @@ module LanguageOperator
         @agent = agent
         @port = port || ENV.fetch('PORT', '8080').to_i
         @routes = {}
-        @executor = Executor.new(agent)
         @mcp_server = nil
         @mcp_transport = nil
 
+        # Initialize executor pool to prevent MCP connection leaks
+        @executor_pool_size = ENV.fetch('EXECUTOR_POOL_SIZE', '4').to_i
+        @executor_pool = setup_executor_pool
+
         setup_default_routes
       end
 
@@ -164,8 +168,49 @@ module LanguageOperator
         error_response(e)
       end
 
+      # Cleanup executor pool and connections
+      #
+      # Properly closes all executors in the pool and their MCP connections
+      # to prevent resource leaks during server shutdown.
+      #
+      # @return [void]
+      def cleanup
+        return unless @executor_pool
+
+        # Drain and cleanup all executors in the pool
+        executors_cleaned = 0
+        begin
+          loop do
+            executor = @executor_pool.pop(timeout: 0.1)
+            if executor
+              executor.cleanup_connections
+              executors_cleaned += 1
+            end
+          end
+        rescue ThreadError
+          # Pool is empty, we're done
+        end
+
+        puts "Cleaned up #{executors_cleaned} executors from pool"
+      end
+
       private
 
+      # Setup executor pool for connection reuse
+      #
+      # Creates a thread-safe queue pre-populated with executor instances
+      # to prevent creating new MCP connections for each webhook request.
+      #
+      # @return [Queue] Thread-safe executor pool
+      def setup_executor_pool
+        pool = Queue.new
+        @executor_pool_size.times do
+          pool << Executor.new(@agent)
+        end
+        puts "Initialized executor pool with #{@executor_pool_size} executors"
+        pool
+      end
+
       # Build the Rack application
       #
       # @return [Rack::Builder]
@@ -235,9 +280,11 @@ module LanguageOperator
       # @param request [Rack::Request] The request
       # @return [Hash] Request context
       def build_request_context(request)
-        # Read body, handling nil case
+        # Read body, handling nil case and rewinding for subsequent reads
         body_content = if request.body
-                         request.body.read
+                         content = request.body.read
+                         request.body.rewind # Reset for subsequent reads by middleware/handlers
+                         content
                        else
                          ''
                        end
@@ -302,20 +349,48 @@ module LanguageOperator
 
       # Handle webhook request by executing agent
       #
+      # Uses executor pooling to prevent MCP connection resource leaks.
+      # Executors are reused across requests to avoid creating new
+      # connections for each webhook request.
+      #
       # @param context [Hash] Request context
       # @return [Hash] Response data
       def handle_webhook(context)
-        # Execute agent with webhook context
-        result = @executor.execute_with_context(
-          instruction: 'Process incoming webhook request',
-          context: context
-        )
+        executor = nil
+        begin
+          # Get executor from pool with timeout
+          executor = @executor_pool.pop(timeout: 5)
+          result = executor.execute_with_context(
+            instruction: 'Process incoming webhook request',
+            context: context
+          )
 
-        {
-          status: 'processed',
-          result: result,
-          timestamp: Time.now.iso8601
-        }
+          {
+            status: 'processed',
+            result: result,
+            timestamp: Time.now.iso8601
+          }
+        rescue ThreadError
+          # Pool exhausted, create temporary executor as fallback
+          temp_executor = Executor.new(@agent)
+          begin
+            result = temp_executor.execute_with_context(
+              instruction: 'Process incoming webhook request',
+              context: context
+            )
+
+            {
+              status: 'processed',
+              result: result,
+              timestamp: Time.now.iso8601
+            }
+          ensure
+            temp_executor.cleanup_connections
+          end
+        ensure
+          # Return executor to pool if we got one
+          @executor_pool.push(executor) if executor
+        end
       end
 
       # Handle MCP protocol request
@@ -536,15 +611,36 @@ module LanguageOperator
       class MockStream
         def initialize(buffer)
           @buffer = buffer
+          @closed = false
         end
 
         def write(data)
+          raise IOError, 'closed stream' if @closed
+
           @buffer.write(data)
         end
 
+        def flush
+          @buffer.flush if @buffer.respond_to?(:flush)
+        end
+
         def close
-          # No-op
+          @closed = true
+        end
+
+        def closed?
+          @closed
+        end
+
+        def sync=(value)
+          # No-op for compatibility
+        end
+
+        # rubocop:disable Naming/PredicateMethod
+        def sync
+          true
         end
+        # rubocop:enable Naming/PredicateMethod
       end
 
       # Called by Rack to stream the response

data/lib/language_operator/agent/webhook_authenticator.rb

@@ -2,11 +2,18 @@
 
 require 'openssl'
 require 'base64'
+require_relative '../logger'
 
 module LanguageOperator
   module Agent
     # Executes webhook authentication checks
     class WebhookAuthenticator
+      @logger = LanguageOperator::Logger.new(component: 'WebhookAuth')
+
+      class << self
+        attr_reader :logger
+      end
+
       # Authenticate a webhook request
       #
       # @param authentication [LanguageOperator::Dsl::WebhookAuthentication] Authentication definition
@@ -88,19 +95,46 @@ module LanguageOperator
         expected_password = config[:password]
 
         auth_header = get_header(context, 'Authorization')
-        return false unless auth_header
+        unless auth_header
+          logger.debug('Basic auth failed: missing Authorization header')
+          return false
+        end
 
         # Extract credentials from "Basic <base64>"
         match = auth_header.match(/^Basic\s+(.+)$/i)
-        return false unless match
+        unless match
+          logger.debug('Basic auth failed: invalid Authorization header format')
+          return false
+        end
 
         begin
           credentials = Base64.decode64(match[1])
           username, password = credentials.split(':', 2)
 
-          secure_compare(username, expected_username) &&
-            secure_compare(password, expected_password)
-        rescue StandardError
+          # Log debugging info for malformed credentials (no colon)
+          if password.nil?
+            logger.debug('Basic auth failed: malformed credentials (no colon separator)',
+                         credentials_length: credentials.length,
+                         contains_colon: credentials.include?(':'))
+            return false
+          end
+
+          username_valid = secure_compare(username, expected_username)
+          password_valid = secure_compare(password, expected_password)
+
+          success = username_valid && password_valid
+
+          unless success
+            logger.debug('Basic auth failed: credential mismatch',
+                         username_valid: username_valid,
+                         password_valid: password_valid)
+          end
+
+          success
+        rescue StandardError => e
+          logger.debug('Basic auth failed: exception during processing',
+                       error: e.class.name,
+                       message: e.message)
           false
         end
       end

data/lib/language_operator/agent.rb

@@ -157,8 +157,8 @@ module LanguageOperator
       case agent.mode
       when 'autonomous', 'interactive'
         if uses_dsl_v1
-          # DSL v1: Execute main block with task executor
-          execute_main_block(agent, agent_def)
+          # DSL v1: Execute main block with task executor in persistent mode
+          execute_main_block_persistent(agent, agent_def)
         elsif uses_dsl_v0
           # DSL v0: Execute workflow in autonomous mode
           executor = LanguageOperator::Agent::Executor.new(agent)
@@ -233,6 +233,92 @@ module LanguageOperator
       result
     end
 
+    # Execute main block (DSL v1) in persistent mode for autonomous agents
+    #
+    # @param agent [LanguageOperator::Agent::Base] The agent instance
+    # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+    # @return [void]
+    def self.execute_main_block_persistent(agent, agent_def)
+      shutdown_requested = setup_signal_handlers
+
+      logger.info('Starting agent in persistent autonomous mode',
+                  agent_name: agent_def.name,
+                  task_count: agent_def.tasks.size)
+
+      # Execute initial main block
+      execute_main_block(agent, agent_def)
+      logger.info('Initial task completed - entering idle state')
+
+      # Enter waiting loop for additional instructions
+      run_idle_loop(shutdown_requested)
+
+      logger.info('Graceful shutdown requested - agent exiting')
+    end
+
+    # Setup signal handlers for graceful shutdown
+    #
+    # @return [Proc] shutdown_requested flag wrapped in a closure
+    def self.setup_signal_handlers
+      shutdown_requested = false
+      trap('TERM') do
+        logger.info('SIGTERM received - requesting graceful shutdown')
+        shutdown_requested = true
+      end
+      trap('INT') do
+        logger.info('SIGINT received - requesting graceful shutdown')
+        shutdown_requested = true
+      end
+
+      -> { shutdown_requested }
+    end
+
+    # Run the idle loop waiting for new instructions
+    #
+    # @param shutdown_requested [Proc] Closure that returns shutdown state
+    # @return [void]
+    def self.run_idle_loop(shutdown_requested)
+      idle_timeout = ENV.fetch('AGENT_IDLE_TIMEOUT', '300').to_i # 5 minutes default
+      last_activity = Time.now
+
+      until shutdown_requested.call
+        begin
+          last_activity = Time.now if handle_new_instruction
+
+          sleep 5 # Avoid busy waiting
+
+          # Reset idle timer when timeout reached (stay persistent)
+          if idle_timeout.positive? && Time.now - last_activity > idle_timeout
+            logger.info('Idle timeout reached - agent remaining available',
+                        timeout_seconds: idle_timeout)
+            last_activity = Time.now
+          end
+        rescue StandardError => e
+          logger.error('Error in idle loop',
+                       error: e.message,
+                       backtrace: e.backtrace[0..3])
+          sleep 10 # Back off on error
+        end
+      end
+    end
+
+    # Handle new instruction from environment variable
+    #
+    # @return [Boolean] True if instruction was processed
+    def self.handle_new_instruction
+      new_instruction = ENV.fetch('AGENT_NEW_INSTRUCTION', nil)
+      return false unless new_instruction && !new_instruction.strip.empty?
+
+      logger.info('New instruction received',
+                  instruction: new_instruction[0..100])
+
+      # Clear the environment variable to prevent re-execution
+      ENV['AGENT_NEW_INSTRUCTION'] = ''
+
+      # Execute the new instruction (implementation would depend on requirements)
+      logger.info('Instruction acknowledged - agent remains in autonomous mode')
+      true
+    end
+
     # Execute the output handler (neural or symbolic)
     #
     # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition

data/lib/language_operator/cli/base_command.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
 require 'thor'
+require_relative 'helpers/ux_helper'
 
 module LanguageOperator
   module CLI
     # Base class for all CLI commands providing shared functionality
+    #
+    # Automatically includes {Helpers::UxHelper} to provide:
+    # - +pastel+ - Colorized terminal output
+    # - +prompt+ - Interactive user prompts
+    #
+    # All commands inheriting from BaseCommand get these helpers automatically.
     class BaseCommand < Thor
+      include Helpers::UxHelper
+
       no_commands do
         # Lazy-initialized cluster context from options
         # @return [Helpers::ClusterContext]
@@ -55,21 +64,16 @@ module LanguageOperator
           exit 1
         end
 
-        # Confirm resource deletion with user
+        # Confirm resource deletion with user (delegates to UxHelper)
         # @param resource_type [String] Type of resource being deleted
         # @param name [String] Resource name
         # @param cluster [String] Cluster name
-        # @param details [Hash] Additional details to display
         # @param force [Boolean] Skip confirmation if true
         # @return [Boolean] True if deletion should proceed
-        def confirm_deletion(resource_type, name, cluster, details: {}, force: false)
+        def confirm_deletion_with_force(resource_type, name, cluster, force: false)
           return true if force
 
-          puts "This will delete #{resource_type} '#{name}' from cluster '#{cluster}':"
-          details.each { |key, value| puts "  #{key}: #{value}" }
-          puts
-
-          Helpers::UserPrompts.confirm('Are you sure?')
+          confirm_deletion(resource_type, name, cluster)
         end
 
         # Check if resource has dependencies and confirm deletion
@@ -94,7 +98,7 @@ module LanguageOperator
             puts 'Delete these agents first, or use --force to delete anyway.'
             puts
 
-            return Helpers::UserPrompts.confirm('Are you sure?')
+            return CLI::Helpers::UserPrompts.confirm('Are you sure?')
           end
 
           true
@@ -102,14 +106,16 @@ module LanguageOperator
 
         # List resources or handle empty state
         # @param type [String] Resource type (e.g., 'LanguageModel')
+        # @param resource_name [String] Human-readable resource name (e.g., 'models')
         # @param empty_message [String, nil] Custom message when no resources found
         # @yield Optional block to execute when list is empty (for guidance)
         # @return [Array<Hash>] List of resources (empty array if none found)
-        def list_resources_or_empty(type, empty_message: nil)
+        def list_resources_or_empty(type, resource_name: nil, empty_message: nil)
           resources = ctx.client.list_resources(type, namespace: ctx.namespace)
 
           if resources.empty?
-            msg = empty_message || "No #{type} resources found in cluster '#{ctx.name}'"
+            resource_display = resource_name || type.downcase.gsub('language', '')
+            msg = empty_message || "No #{resource_display} found"
             Formatters::ProgressFormatter.info(msg)
             yield if block_given?
           end

data/lib/language_operator/cli/command_loader.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# CommandLoader - Single require point for all CLI commands
+#
+# This module eliminates duplication across command files by auto-loading
+# all common formatters, helpers, and dependencies.
+#
+# Before CommandLoader, each command file had 15+ duplicate require statements.
+# Now commands just need: require_relative '../command_loader'
+#
+# Usage in command files:
+#   require_relative '../command_loader'
+#   require_relative '../wizards/my_wizard'  # command-specific requires only
+#
+#   class MyCommand < BaseCommand
+#     include Constants  # For RESOURCE_* constants
+#
+#     def some_method
+#       ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
+#     end
+#   end
+
+module LanguageOperator
+  module CLI
+    module CommandLoader
+      # Auto-load all common CLI dependencies
+      # This runs once when the module is first required
+      def self.setup
+        # Core base class (must load first)
+        require_relative 'base_command'
+
+        # Constants for resource types
+        require_relative '../constants'
+
+        # Formatters - visual output and progress indicators
+        require_relative 'formatters/progress_formatter'
+        require_relative 'formatters/table_formatter'
+        require_relative 'formatters/value_formatter'
+        require_relative 'formatters/log_formatter'
+        require_relative 'formatters/status_formatter'
+        require_relative 'formatters/code_formatter'
+        require_relative 'formatters/log_style'
+        # require_relative 'formatters/optimization_formatter'
+
+        # Helpers - shared utilities and validations
+        require_relative 'helpers/cluster_validator'
+        require_relative 'helpers/cluster_context'
+        require_relative 'helpers/user_prompts'
+        require_relative 'helpers/editor_helper'
+        require_relative 'helpers/resource_dependency_checker'
+        require_relative 'helpers/ux_helper'
+        require_relative 'helpers/validation_helper'
+        require_relative 'helpers/provider_helper'
+        require_relative 'helpers/schedule_builder'
+        require_relative 'helpers/kubeconfig_validator'
+
+        # Error handling
+        require_relative 'errors/handler'
+        require_relative 'errors/suggestions'
+
+        # Configuration and Kubernetes clients
+        require_relative '../config/cluster_config'
+        require_relative '../config/tool_registry'
+        require_relative '../kubernetes/client'
+        require_relative '../kubernetes/resource_builder'
+      end
+    end
+  end
+end
+
+# Auto-setup when this file is required
+LanguageOperator::CLI::CommandLoader.setup