language-operator 0.1.70 → 0.1.80

data/lib/language_operator/agent/web_server.rb

@@ -3,7 +3,10 @@
 require 'rack'
 require 'rackup'
 require 'mcp'
+require 'fileutils'
+require 'securerandom'
 require_relative 'executor'
+require_relative 'prompt_builder'
 
 module LanguageOperator
   module Agent
@@ -29,6 +32,7 @@ module LanguageOperator
         @routes = {}
         @mcp_server = nil
         @mcp_transport = nil
+        @execution_state = nil # Initialized when register_execute_endpoint called
 
         # Initialize executor pool to prevent MCP connection leaks
         @executor_pool_size = ENV.fetch('EXECUTOR_POOL_SIZE', '4').to_i
@@ -110,16 +114,22 @@ module LanguageOperator
 
       # Register chat completion endpoint
       #
-      # Sets up OpenAI-compatible chat completion endpoint.
-      # Agents can be used as drop-in LLM replacements.
+      # Sets up OpenAI-compatible chat completion endpoint for all agents.
+      # Every agent automatically gets identity-aware chat capabilities.
       #
-      # @param chat_endpoint_def [LanguageOperator::Dsl::ChatEndpointDefinition] Chat endpoint definition
       # @param agent [LanguageOperator::Agent::Base] The agent instance
       # @return [void]
-      def register_chat_endpoint(chat_endpoint_def, agent)
-        @chat_endpoint = chat_endpoint_def
+      def register_chat_endpoint(agent)
         @chat_agent = agent
 
+        # Create simple chat configuration (identity awareness always enabled)
+        @chat_config = {
+          model_name: ENV.fetch('AGENT_NAME', agent.config&.dig('agent', 'name') || 'agent'),
+          system_prompt: build_default_system_prompt(agent),
+          temperature: 0.7,
+          max_tokens: 2000
+        }
+
         # Register OpenAI-compatible endpoint
         register_route('/v1/chat/completions', method: :post) do |context|
           handle_chat_completion(context)
@@ -131,19 +141,78 @@ module LanguageOperator
             object: 'list',
             data: [
               {
-                id: chat_endpoint_def.model_name,
+                id: @chat_config[:model_name],
                 object: 'model',
                 created: Time.now.to_i,
                 owned_by: 'language-operator',
                 permission: [],
-                root: chat_endpoint_def.model_name,
+                root: @chat_config[:model_name],
                 parent: nil
               }
             ]
           }
         end
 
-        puts "Registered chat completion endpoint as model: #{chat_endpoint_def.model_name}"
+        puts "Registered identity-aware chat endpoint as model: #{@chat_config[:model_name]}"
+      end
+
+      # Register execution trigger endpoint
+      #
+      # Enables scheduled/reactive agents to execute tasks via HTTP POST.
+      # Prevents concurrent executions via ExecutionState.
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      # @param agent_def [LanguageOperator::Dsl::AgentDefinition, nil] Optional agent definition
+      # @return [void]
+      def register_execute_endpoint(agent, agent_def = nil)
+        require_relative 'execution_state'
+
+        @execute_agent = agent
+        @execute_agent_def = agent_def
+        @execution_state = LanguageOperator::Agent::ExecutionState.new
+
+        register_route('/api/v1/execute', method: :post) do |context|
+          handle_execute_request(context)
+        end
+
+        puts 'Registered /api/v1/execute endpoint for triggered execution'
+      end
+
+      # Register workspace file management endpoints
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      def register_workspace_endpoints(agent)
+        return unless agent.workspace_available?
+
+        @workspace_agent = agent
+        @workspace_path = agent.workspace_path
+
+        # List directory contents
+        register_route('/api/v1/workspace/files', method: :get) do |context|
+          handle_workspace_list(context)
+        end
+
+        # View file contents
+        register_route('/api/v1/workspace/files/view', method: :get) do |context|
+          handle_workspace_view(context)
+        end
+
+        # Upload file
+        register_route('/api/v1/workspace/files', method: :post) do |context|
+          handle_workspace_upload(context)
+        end
+
+        # Delete file
+        register_route('/api/v1/workspace/files', method: :delete) do |context|
+          handle_workspace_delete(context)
+        end
+
+        # Download file/directory
+        register_route('/api/v1/workspace/files/download', method: :get) do |context|
+          handle_workspace_download(context)
+        end
+
+        puts 'Registered /api/v1/workspace/* endpoints for file management'
       end
 
       # Handle incoming HTTP request
@@ -193,6 +262,163 @@ module LanguageOperator
 
       private
 
+      # Build default system prompt for agent
+      #
+      # Creates a basic system prompt based on agent description
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      # @return [String] Default system prompt
+      def build_default_system_prompt(agent)
+        description = agent.config&.dig('agent', 'instructions') ||
+                      agent.config&.dig('agent', 'description') ||
+                      'AI assistant'
+
+        if description.downcase.start_with?('you are')
+          description
+        else
+          "You are #{description.downcase}. Provide helpful assistance based on your capabilities."
+        end
+      end
+
+      # Handle POST /api/v1/execute request
+      #
+      # @param context [Hash] Request context with :body, :headers, :request
+      # @return [Hash] Response data
+      def handle_execute_request(context)
+        puts "Received execute request: #{context[:body]}"
+
+        # Check for concurrent execution
+        if @execution_state.running?
+          info = @execution_state.current_info
+          puts "Execution already running: #{info}"
+          return {
+            status: 409,
+            body: {
+              error: 'ExecutionInProgress',
+              message: 'Agent is currently executing a task',
+              current_execution: info
+            }.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        end
+
+        # Parse request
+        request_data = JSON.parse(context[:body] || '{}')
+        puts "Parsed request data: #{request_data.inspect}"
+
+        execution_id = "exec-#{SecureRandom.hex(8)}"
+        puts "Generated execution ID: #{execution_id}"
+
+        wait_for_completion = request_data.fetch('wait', true)
+        puts "Execution details - ID: #{execution_id}, wait: #{wait_for_completion}"
+
+        # Start execution
+        puts 'About to start execution state...'
+        @execution_state.start_execution(execution_id)
+        puts "Started execution state for #{execution_id}"
+
+        if wait_for_completion
+          execute_sync(execution_id, request_data['context'])
+        else
+          execute_async(execution_id, request_data['context'])
+        end
+      rescue JSON::ParserError
+        execute_error_response(400, 'InvalidJSON', 'Request body must be valid JSON')
+      rescue LanguageOperator::Agent::ExecutionInProgressError => e
+        execute_error_response(409, 'ExecutionInProgress', e.message)
+      rescue StandardError => e
+        puts "Exception in handle_execute_request: #{e.class}: #{e.message}"
+        puts "Exception backtrace: #{e.backtrace.first(5).join('\n')}"
+        @execution_state&.fail_execution(e)
+        execute_error_response(500, 'ExecutionError', e.message)
+      end
+
+      # Execute task synchronously
+      #
+      # @param execution_id [String] Execution identifier
+      # @param context_data [Hash] Additional context data
+      # @return [Hash] Response data
+      def execute_sync(execution_id, _context_data)
+        start_time = Time.now
+        puts "Starting execution #{execution_id}"
+
+        # Execute agent main block (convention: all DSL agents have main blocks)
+        puts 'About to execute main block...'
+        $stdout.flush
+
+        # Test logging capture during execution
+        original_stdout = $stdout
+        original_stderr = $stderr
+        puts "Original stdout: #{original_stdout.class}"
+        puts "Original stderr: #{original_stderr.class}"
+        $stdout.flush
+
+        result = LanguageOperator::Agent.execute_main_block(@execute_agent, @execute_agent_def)
+
+        puts "Main block execution returned: #{result.inspect}"
+        puts "Stdout after execution: #{$stdout.class}"
+        puts "Stderr after execution: #{$stderr.class}"
+        $stdout.flush
+
+        puts "Execution #{execution_id} completed with result: #{result.inspect}"
+        @execution_state.complete_execution(result)
+
+        {
+          status: 200,
+          body: {
+            status: 'completed',
+            result: result,
+            execution_id: execution_id,
+            started_at: start_time.iso8601,
+            completed_at: Time.now.iso8601,
+            duration_seconds: (Time.now - start_time).round(2)
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Execute task asynchronously
+      #
+      # @param execution_id [String] Execution identifier
+      # @param context_data [Hash] Additional context data
+      # @return [Hash] Response data
+      def execute_async(execution_id, _context_data)
+        Thread.new do
+          result = LanguageOperator::Agent.execute_main_block(@execute_agent, @execute_agent_def)
+          @execution_state.complete_execution(result)
+        rescue StandardError => e
+          @execution_state.fail_execution(e)
+          logger.error('Async execution failed', error: e.message, execution_id: execution_id)
+        end
+
+        {
+          status: 202,
+          body: {
+            status: 'accepted',
+            execution_id: execution_id,
+            message: 'Execution started asynchronously'
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Generate error response for execute endpoint
+      #
+      # @param status [Integer] HTTP status code
+      # @param error_type [String] Error type identifier
+      # @param message [String] Error message
+      # @return [Hash] Error response data
+      def execute_error_response(status, error_type, message)
+        {
+          status: status,
+          body: {
+            error: error_type,
+            message: message
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
       # Setup executor pool for connection reuse
       #
       # Creates a thread-safe queue pre-populated with executor instances
@@ -406,7 +632,7 @@ module LanguageOperator
       # @param context [Hash] Request context
       # @return [Array, Hash] Rack response or hash for streaming
       def handle_chat_completion(context)
-        return error_response(StandardError.new('Chat endpoint not configured')) unless @chat_endpoint
+        return error_response(StandardError.new('Chat endpoint not configured')) unless @chat_config
 
         # Parse request body
         request_data = JSON.parse(context[:body])
@@ -444,7 +670,7 @@ module LanguageOperator
           id: "chatcmpl-#{SecureRandom.hex(12)}",
           object: 'chat.completion',
           created: Time.now.to_i,
-          model: @chat_endpoint.model_name,
+          model: @chat_config[:model_name],
           choices: [
             {
               index: 0,
@@ -480,41 +706,79 @@ module LanguageOperator
             'Cache-Control' => 'no-cache',
             'Connection' => 'keep-alive'
           },
-          StreamingBody.new(@chat_agent, prompt, @chat_endpoint.model_name)
+          StreamingBody.new(@chat_agent, prompt, @chat_config[:model_name])
         ]
       end
 
-      # Build prompt from OpenAI message format
+      # Build prompt from OpenAI message format with identity awareness
       #
       # @param messages [Array<Hash>] Array of message objects
-      # @return [String] Combined prompt
+      # @return [String] Combined prompt with agent identity context
       def build_prompt_from_messages(messages)
-        # Combine all messages into a single prompt
-        # System messages become instructions
-        # User/assistant messages become conversation
         prompt_parts = []
 
-        # Add system prompt if configured
-        prompt_parts << "System: #{@chat_endpoint.system_prompt}" if @chat_endpoint.system_prompt
+        # Build identity-aware system prompt (always enabled)
+        system_prompt = build_identity_aware_system_prompt
+        prompt_parts << "System: #{system_prompt}" if system_prompt
+
+        # Add conversation context (always enabled)
+        conversation_context = build_conversation_context
+        prompt_parts << conversation_context if conversation_context
 
-        # Add conversation history
+        # Add conversation history (skip system messages from original array since we handle them above)
         messages.each do |msg|
           role = msg['role']
           content = msg['content']
 
           case role
-          when 'system'
-            prompt_parts << "System: #{content}"
           when 'user'
             prompt_parts << "User: #{content}"
           when 'assistant'
             prompt_parts << "Assistant: #{content}"
+            # Skip system messages - we handle them via PromptBuilder
           end
         end
 
         prompt_parts.join("\n\n")
       end
 
+      # Build identity-aware system prompt using PromptBuilder
+      #
+      # @return [String] Dynamic system prompt with agent identity
+      def build_identity_aware_system_prompt
+        # Create prompt builder with identity awareness always enabled
+        builder = PromptBuilder.new(
+          @chat_agent,
+          nil, # No chat config needed
+          template: :standard, # Good default
+          enable_identity_awareness: true
+        )
+
+        builder.build_system_prompt
+      rescue StandardError => e
+        # Log error and fall back to static prompt
+        puts "Warning: Failed to build identity-aware system prompt: #{e.message}"
+        @chat_config[:system_prompt]
+      end
+
+      # Build conversation context for ongoing chats
+      #
+      # @return [String, nil] Conversation context
+      def build_conversation_context
+        builder = PromptBuilder.new(
+          @chat_agent,
+          nil, # No chat config needed
+          enable_identity_awareness: true
+        )
+
+        context = builder.build_conversation_context
+        context ? "Context: #{context}" : nil
+      rescue StandardError => e
+        # Log error and continue without context
+        puts "Warning: Failed to build conversation context: #{e.message}"
+        nil
+      end
+
       # Estimate token count (rough approximation)
       #
       # @param text [String] Text to estimate
@@ -701,6 +965,331 @@ module LanguageOperator
       ensure
         stream.close
       end
+
+      # Workspace file management handlers
+
+      # Handle GET /api/v1/workspace/files - list directory contents
+      def handle_workspace_list(context)
+        request = context[:request]
+        path = request.params['path'] || '/'
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        if File.directory?(full_path)
+          list_directory_contents(full_path, path)
+        else
+          # If it's a file, return file info
+          get_file_info(full_path, path)
+        end
+      rescue StandardError => e
+        workspace_error_response(500, 'InternalError', e.message)
+      end
+
+      # Handle GET /api/v1/workspace/files/view - view file contents
+      def handle_workspace_view(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "File not found: #{path}") unless File.exist?(full_path)
+
+        return workspace_error_response(400, 'BadRequest', "Path is not a file: #{path}") unless File.file?(full_path)
+
+        # Check file size (limit to 10MB for API responses)
+        file_size = File.size(full_path)
+        return workspace_error_response(413, 'FileTooLarge', 'File too large for viewing (max 10MB)') if file_size > 10 * 1024 * 1024
+
+        # Read file contents
+        contents = File.read(full_path)
+
+        {
+          status: 200,
+          body: {
+            path: path,
+            size: file_size,
+            modified: File.mtime(full_path).iso8601,
+            content: contents,
+            content_type: detect_content_type(full_path)
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      rescue StandardError => e
+        workspace_error_response(500, 'InternalError', e.message)
+      end
+
+      # Handle POST /api/v1/workspace/files - upload file
+      def handle_workspace_upload(context)
+        request = context[:request]
+
+        # Check for multipart form data
+        content_type = request.env['CONTENT_TYPE']
+        unless content_type&.start_with?('multipart/form-data')
+          return workspace_error_response(400, 'BadRequest', 'Content-Type must be multipart/form-data')
+        end
+
+        # Parse multipart data
+        begin
+          # Get file from params (Rack automatically parses multipart data)
+          file_param = request.params['file']
+          path_param = request.params['path']
+
+          return workspace_error_response(400, 'BadRequest', 'file parameter required') unless file_param
+
+          return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path_param
+
+          # Handle file upload object
+          return workspace_error_response(400, 'BadRequest', 'Invalid file upload format') unless file_param.is_a?(Hash) && file_param[:tempfile]
+
+          # Rack file upload format
+          tempfile = file_param[:tempfile]
+          original_filename = file_param[:filename]
+          content_type = file_param[:type]
+
+          # Sanitize target path
+          safe_path = sanitize_workspace_path(path_param)
+          full_path = File.join(@workspace_path, safe_path)
+
+          # Ensure target directory exists
+          target_dir = File.dirname(full_path)
+          FileUtils.mkdir_p(target_dir) unless File.directory?(target_dir)
+
+          # Check file size (limit to 100MB)
+          file_size = tempfile.size
+          return workspace_error_response(413, 'FileTooLarge', 'File too large for upload (max 100MB)') if file_size > 100 * 1024 * 1024
+
+          # Copy uploaded file to workspace
+          tempfile.rewind
+          File.open(full_path, 'wb') do |dest_file|
+            IO.copy_stream(tempfile, dest_file)
+          end
+
+          # Set reasonable permissions
+          File.chmod(0o644, full_path)
+
+          {
+            status: 201,
+            body: {
+              path: path_param,
+              size: file_size,
+              original_filename: original_filename,
+              content_type: content_type,
+              message: 'File uploaded successfully'
+            }.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        rescue StandardError => e
+          workspace_error_response(500, 'UploadError', "Upload failed: #{e.message}")
+        ensure
+          # Clean up temporary file
+          tempfile&.close if tempfile.respond_to?(:close)
+        end
+      end
+
+      # Handle DELETE /api/v1/workspace/files - delete file
+      def handle_workspace_delete(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        begin
+          deleted_info = {
+            path: path,
+            type: File.directory?(full_path) ? 'directory' : 'file',
+            size: File.directory?(full_path) ? nil : File.size(full_path)
+          }
+
+          if File.directory?(full_path)
+            # Delete directory and all contents
+            FileUtils.rm_rf(full_path)
+            deleted_info[:message] = 'Directory deleted successfully'
+          else
+            # Delete single file
+            File.delete(full_path)
+            deleted_info[:message] = 'File deleted successfully'
+          end
+
+          {
+            status: 200,
+            body: deleted_info.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        rescue StandardError => e
+          workspace_error_response(500, 'DeleteError', "Delete failed: #{e.message}")
+        end
+      end
+
+      # Handle GET /api/v1/workspace/files/download - download file/archive
+      def handle_workspace_download(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        begin
+          if File.directory?(full_path)
+            # Create temporary tar.gz archive for directory
+            archive_name = "#{File.basename(safe_path.empty? ? 'workspace' : safe_path)}.tar.gz"
+            temp_archive = "/tmp/#{SecureRandom.hex(8)}_#{archive_name}"
+
+            # Create tar archive
+            system('tar', '-czf', temp_archive, '-C', File.dirname(full_path), File.basename(full_path))
+
+            return workspace_error_response(500, 'ArchiveError', 'Failed to create archive') unless File.exist?(temp_archive)
+
+            # Read archive contents
+            archive_data = File.binread(temp_archive)
+
+            # Clean up temporary file
+            File.delete(temp_archive)
+
+            {
+              status: 200,
+              body: archive_data,
+              headers: {
+                'Content-Type' => 'application/gzip',
+                'Content-Disposition' => "attachment; filename=\"#{archive_name}\"",
+                'Content-Length' => archive_data.length.to_s
+              }
+            }
+          else
+            # Direct file download
+            file_data = File.binread(full_path)
+            filename = File.basename(safe_path)
+            content_type = detect_content_type(full_path)
+
+            # For binary files, use application/octet-stream
+            content_disposition = if content_type == 'application/octet-stream'
+                                    "attachment; filename=\"#{filename}\""
+                                  else
+                                    # For text files, allow inline viewing
+                                    "inline; filename=\"#{filename}\""
+                                  end
+
+            {
+              status: 200,
+              body: file_data,
+              headers: {
+                'Content-Type' => content_type,
+                'Content-Disposition' => content_disposition,
+                'Content-Length' => file_data.length.to_s
+              }
+            }
+          end
+        rescue StandardError => e
+          workspace_error_response(500, 'DownloadError', "Download failed: #{e.message}")
+        end
+      end
+
+      private
+
+      # Sanitize workspace path to prevent directory traversal attacks
+      def sanitize_workspace_path(path)
+        # Remove leading slash and resolve relative paths
+        clean_path = path.sub(%r{^/+}, '')
+
+        # Resolve and normalize the path
+        normalized = File.expand_path(clean_path, '/')
+
+        # Ensure it doesn't escape the root
+        return '' if normalized == '/' || !normalized.start_with?('/')
+
+        # Remove leading slash for joining with workspace_path
+        normalized[1..]
+      end
+
+      # List directory contents
+      def list_directory_contents(full_path, requested_path)
+        entries = Dir.entries(full_path).reject { |entry| entry.start_with?('.') }
+
+        files = entries.map do |entry|
+          entry_path = File.join(full_path, entry)
+          relative_path = File.join(requested_path == '/' ? '' : requested_path, entry)
+
+          {
+            name: entry,
+            path: "/#{relative_path}".gsub(%r{/+}, '/'),
+            type: File.directory?(entry_path) ? 'directory' : 'file',
+            size: File.directory?(entry_path) ? nil : File.size(entry_path),
+            modified: File.mtime(entry_path).iso8601
+          }
+        end
+
+        files.sort_by! { |f| [f[:type] == 'directory' ? 0 : 1, f[:name]] }
+
+        {
+          status: 200,
+          body: {
+            path: requested_path,
+            files: files,
+            total: files.length
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Get file info for a single file
+      def get_file_info(full_path, requested_path)
+        {
+          status: 200,
+          body: {
+            path: requested_path,
+            type: 'file',
+            size: File.size(full_path),
+            modified: File.mtime(full_path).iso8601
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Detect content type based on file extension
+      def detect_content_type(file_path)
+        case File.extname(file_path).downcase
+        when '.txt', '.log' then 'text/plain'
+        when '.json' then 'application/json'
+        when '.yml', '.yaml' then 'application/x-yaml'
+        when '.md' then 'text/markdown'
+        when '.html' then 'text/html'
+        when '.css' then 'text/css'
+        when '.js' then 'application/javascript'
+        when '.py' then 'text/x-python'
+        when '.rb' then 'text/x-ruby'
+        else 'application/octet-stream'
+        end
+      end
+
+      # Generate workspace API error response
+      def workspace_error_response(status, error_type, message)
+        {
+          status: status,
+          body: {
+            error: error_type,
+            message: message
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
     end
   end
 end