language-operator 0.0.1 → 0.1.31

data/lib/language_operator/agent/safety/safe_executor.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Agent
+    module Safety
+      # Executes Ruby code in a sandboxed context with method whitelisting
+      # Wraps the execution context to prevent dangerous method calls at runtime
+      class SafeExecutor
+        class SecurityError < StandardError; end
+
+        # Methods that are always safe to call
+        ALWAYS_SAFE_METHODS = %i[
+          nil? == != eql? equal? hash object_id class is_a? kind_of? instance_of?
+          respond_to? send_to? methods public_methods private_methods
+          instance_variables instance_variable_get instance_variable_set
+          to_s to_str inspect to_a to_h to_i to_f to_sym
+          freeze frozen? dup clone
+        ].freeze
+
+        def initialize(context, validator: nil)
+          @context = context
+          @validator = validator || ASTValidator.new
+          @audit_log = []
+        end
+
+        # Execute code in the sandboxed context
+        # @param code [String] Ruby code to execute
+        # @param file_path [String] Path to file (for error reporting)
+        # @return [Object] Result of code execution
+        def eval(code, file_path = '(eval)')
+          # Step 1: Validate code with AST analysis
+          @validator.validate!(code, file_path)
+
+          # Step 2: Execute in sandboxed context
+          sandbox = SandboxProxy.new(@context, self)
+
+          # Step 3: Execute using instance_eval
+          # Note: We still use instance_eval but with validated code
+          # and wrapped context
+          sandbox.instance_eval(code, file_path)
+        rescue ASTValidator::SecurityError => e
+          # Re-raise validation errors as executor errors for clarity
+          raise SecurityError, "Code validation failed: #{e.message}"
+        end
+
+        # Log method calls for auditing
+        def log_call(receiver, method_name, args)
+          @audit_log << {
+            timestamp: Time.now,
+            receiver: receiver.class.name,
+            method: method_name,
+            args: args.map(&:class).map(&:name)
+          }
+        end
+
+        # Get audit log
+        attr_reader :audit_log
+
+        # Proxy class that wraps the context and intercepts method calls
+        class SandboxProxy < BasicObject
+          def initialize(context, executor)
+            @__context__ = context
+            @__executor__ = executor
+          end
+
+          # Delegate method calls to the underlying context
+          # but check for dangerous methods first
+          def method_missing(method_name, *args, &)
+            # Log the call
+            @__executor__.log_call(@__context__, method_name, args)
+
+            # Special handling for require - allow only 'language_operator'
+            if %i[require require_relative].include?(method_name)
+              required_gem = args.first.to_s
+              return ::Kernel.require(required_gem) if required_gem == 'language_operator'
+
+              # Allow require 'language_operator'
+
+              ::Kernel.raise ::LanguageOperator::Agent::Safety::SafeExecutor::SecurityError,
+                             "Require '#{required_gem}' is not allowed. Only 'require \"language_operator\"' is permitted."
+
+            end
+
+            # Check if method is safe
+            unless safe_method?(method_name)
+              ::Kernel.raise ::LanguageOperator::Agent::Safety::SafeExecutor::SecurityError,
+                             "Method '#{method_name}' is not allowed in sandboxed code"
+            end
+
+            # Delegate to underlying context
+            @__context__.send(method_name, *args, &)
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            @__context__.respond_to?(method_name, include_private)
+          end
+
+          # Provide access to safe constants from the context
+          def const_missing(name)
+            # Allow access to HTTP and Shell helper classes
+            if name == :HTTP
+              return ::LanguageOperator::Dsl::HTTP
+            elsif name == :Shell
+              return ::LanguageOperator::Dsl::Shell
+            end
+
+            # Otherwise delegate to the context's module
+            @__context__.class.const_get(name)
+          rescue ::NameError
+            ::Kernel.raise ::NameError, "uninitialized constant #{name}"
+          end
+
+          private
+
+          def safe_method?(method_name)
+            # Always allow safe basic methods
+            return true if ::LanguageOperator::Agent::Safety::SafeExecutor::ALWAYS_SAFE_METHODS.include?(method_name)
+
+            # Check if the underlying context responds to the method
+            # (This allows DSL methods defined on the context)
+            @__context__.respond_to?(method_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/agent/scheduler.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'rufus-scheduler'
+require_relative 'executor'
+require_relative 'instrumentation'
+require_relative '../logger'
+require_relative '../loggable'
+
+module LanguageOperator
+  module Agent
+    # Task Scheduler
+    #
+    # Handles scheduled and event-driven task execution using rufus-scheduler.
+    #
+    # @example
+    #   scheduler = Scheduler.new(agent)
+    #   scheduler.start
+    class Scheduler
+      include LanguageOperator::Loggable
+      include LanguageOperator::Agent::Instrumentation
+
+      attr_reader :agent, :rufus_scheduler
+
+      # Initialize the scheduler
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      def initialize(agent)
+        @agent = agent
+        @rufus_scheduler = Rufus::Scheduler.new
+        @executor = Executor.new(agent)
+
+        logger.debug('Scheduler initialized',
+                     workspace: @agent.workspace_path,
+                     servers: @agent.servers_info.length)
+      end
+
+      # Start the scheduler
+      #
+      # @return [void]
+      def start
+        logger.info('Agent starting in scheduled mode')
+        logger.info("Workspace: #{@agent.workspace_path}")
+        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
+
+        setup_schedules
+        logger.info('Scheduler started, waiting for scheduled tasks')
+        @rufus_scheduler.join
+      end
+
+      # Start the scheduler with a workflow definition
+      #
+      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition with workflow
+      # @return [void]
+      def start_with_workflow(agent_def)
+        logger.info('Agent starting in scheduled mode with workflow',
+                    agent_name: agent_def.name,
+                    has_workflow: !agent_def.workflow.nil?)
+        logger.info("Workspace: #{@agent.workspace_path}")
+        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
+
+        # Extract schedule from agent definition or use default
+        cron_schedule = agent_def.schedule&.cron || '0 6 * * *'
+
+        logger.info('Scheduling workflow', cron: cron_schedule, agent: agent_def.name)
+
+        @rufus_scheduler.cron(cron_schedule) do
+          with_span('agent.scheduler.execute', attributes: {
+                      'scheduler.cron_expression' => cron_schedule,
+                      'agent.name' => agent_def.name,
+                      'scheduler.task_type' => 'workflow'
+                    }) do
+            logger.timed('Scheduled workflow execution') do
+              logger.info('Executing scheduled workflow', agent: agent_def.name)
+              result = @executor.execute_workflow(agent_def)
+              result_text = result.is_a?(String) ? result : result.content
+              preview = result_text[0..200]
+              preview += '...' if result_text.length > 200
+              logger.info('Workflow completed', result_preview: preview)
+            end
+          end
+        end
+
+        logger.info('Scheduler started, waiting for scheduled tasks')
+        @rufus_scheduler.join
+      end
+
+      # Stop the scheduler
+      #
+      # @return [void]
+      def stop
+        logger.info('Shutting down scheduler')
+        @rufus_scheduler.shutdown
+        logger.info('Scheduler stopped')
+      end
+
+      private
+
+      def logger_component
+        'Agent::Scheduler'
+      end
+
+      # Setup schedules from config
+      #
+      # @return [void]
+      def setup_schedules
+        schedules = @agent.config.dig('agent', 'schedules') || []
+
+        logger.debug('Loading schedules from config', count: schedules.length)
+
+        if schedules.empty?
+          logger.warn('No schedules configured, using default daily schedule')
+          setup_default_schedule
+          return
+        end
+
+        schedules.each do |schedule|
+          add_schedule(schedule)
+        end
+
+        logger.info("#{schedules.length} schedule(s) configured")
+      end
+
+      # Add a single schedule
+      #
+      # @param schedule [Hash] Schedule configuration
+      # @return [void]
+      def add_schedule(schedule)
+        cron = schedule['cron']
+        task = schedule['task']
+        agent_name = @agent.config.dig('agent', 'name')
+
+        logger.info('Scheduling task', cron: cron, task: task[0..100])
+
+        @rufus_scheduler.cron(cron) do
+          with_span('agent.scheduler.execute', attributes: {
+                      'scheduler.cron_expression' => cron,
+                      'agent.name' => agent_name,
+                      'scheduler.task_type' => 'scheduled'
+                    }) do
+            logger.timed('Scheduled task execution') do
+              logger.info('Executing scheduled task', task: task[0..100])
+              result = @executor.execute(task)
+              preview = result[0..200]
+              preview += '...' if result.length > 200
+              logger.info('Task completed', result_preview: preview)
+            end
+          end
+        end
+      end
+
+      # Setup default daily schedule
+      #
+      # @return [void]
+      def setup_default_schedule
+        instructions = @agent.config.dig('agent', 'instructions') ||
+                       'Check for updates and report status'
+        agent_name = @agent.config.dig('agent', 'name')
+        cron = '0 6 * * *'
+
+        logger.info('Setting up default schedule', cron: cron,
+                                                   instructions: instructions[0..100])
+
+        @rufus_scheduler.cron(cron) do
+          with_span('agent.scheduler.execute', attributes: {
+                      'scheduler.cron_expression' => cron,
+                      'agent.name' => agent_name,
+                      'scheduler.task_type' => 'default'
+                    }) do
+            logger.timed('Daily task execution') do
+              logger.info('Executing daily task')
+              result = @executor.execute(instructions)
+              preview = result[0..200]
+              preview += '...' if result.length > 200
+              logger.info('Daily task completed', result_preview: preview)
+            end
+          end
+        end
+
+        logger.info('Scheduled: Daily at 6:00 AM')
+      end
+    end
+  end
+end

data/lib/language_operator/agent/telemetry.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/sdk'
+require 'opentelemetry/exporter/otlp'
+
+module LanguageOperator
+  module Agent
+    # OpenTelemetry configuration for agent runtime
+    #
+    # Initializes distributed tracing and telemetry for language operator agents.
+    # Reads configuration from environment variables and gracefully handles errors.
+    #
+    # @example Configure telemetry
+    #   LanguageOperator::Agent::Telemetry.configure
+    module Telemetry
+      class << self
+        # Configure OpenTelemetry for the agent
+        #
+        # Reads configuration from environment variables:
+        # - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP endpoint URL (required)
+        # - TRACEPARENT: W3C trace context for distributed tracing
+        # - AGENT_NAMESPACE: Kubernetes namespace
+        # - AGENT_NAME: Agent name
+        # - AGENT_MODE: Agent operating mode
+        # - HOSTNAME: Pod hostname
+        #
+        # @return [void]
+        def configure
+          endpoint = ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil)
+          return unless endpoint
+
+          OpenTelemetry::SDK.configure do |c|
+            c.service_name = 'language-operator-agent'
+            c.service_version = LanguageOperator::VERSION
+
+            # Configure resource attributes
+            c.resource = OpenTelemetry::SDK::Resources::Resource.create(
+              build_resource_attributes
+            )
+
+            # Configure OTLP exporter
+            c.add_span_processor(
+              OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+                OpenTelemetry::Exporter::OTLP::Exporter.new(
+                  endpoint: endpoint
+                )
+              )
+            )
+          end
+
+          # Restore trace context from TRACEPARENT if present
+          restore_trace_context if ENV['TRACEPARENT']
+        rescue StandardError => e
+          warn "Failed to configure OpenTelemetry: #{e.message}"
+          warn e.backtrace.join("\n")
+        end
+
+        private
+
+        # Build resource attributes from environment variables
+        #
+        # @return [Hash] Resource attributes
+        def build_resource_attributes
+          attributes = {}
+
+          # Service namespace
+          if (namespace = ENV.fetch('AGENT_NAMESPACE', nil))
+            attributes['service.namespace'] = namespace
+            attributes['k8s.namespace.name'] = namespace
+          end
+
+          # Kubernetes pod name
+          attributes['k8s.pod.name'] = ENV['HOSTNAME'] if ENV['HOSTNAME']
+
+          # Agent-specific attributes
+          attributes['agent.name'] = ENV['AGENT_NAME'] if ENV['AGENT_NAME']
+          attributes['agent.mode'] = ENV['AGENT_MODE'] if ENV['AGENT_MODE']
+
+          attributes
+        end
+
+        # Restore trace context from TRACEPARENT environment variable
+        #
+        # Extracts W3C trace context and sets it as the current context,
+        # enabling distributed tracing across service boundaries.
+        #
+        # @return [void]
+        def restore_trace_context
+          traceparent = ENV.fetch('TRACEPARENT', nil)
+          return unless traceparent
+
+          # Parse TRACEPARENT (format: version-trace_id-parent_id-flags)
+          parts = traceparent.split('-')
+          return unless parts.length == 4
+
+          _version, trace_id, parent_id, _flags = parts
+
+          # Create span context from extracted values
+          span_context = OpenTelemetry::Trace::SpanContext.new(
+            trace_id: [trace_id].pack('H*'),
+            span_id: [parent_id].pack('H*'),
+            trace_flags: OpenTelemetry::Trace::TraceFlags::SAMPLED,
+            remote: true
+          )
+
+          # Set as current context using proper OpenTelemetry API
+          span = OpenTelemetry::Trace.non_recording_span(span_context)
+          context = OpenTelemetry::Trace.context_with_span(span)
+          OpenTelemetry::Context.attach(context)
+        rescue StandardError => e
+          warn "Failed to restore trace context: #{e.message}"
+        end
+      end
+    end
+  end
+end