igniter 0.5.1 → 0.5.2

data/packages/igniter-server/lib/igniter/server/handlers/agent_message_handler.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class AgentMessageHandler < Base
-        def initialize(registry, store, session_store:, mode:) # rubocop:disable Lint/UnusedMethodArgument
-          super(registry, store)
-          @session_store = session_store
-          @mode = mode.to_sym
-        end
-
-        private
-
-        def handle(params:, body:)
-          require "igniter/agent"
-
-          node = build_node(params, body)
-          adapter = Igniter::Runtime::RegistryAgentAdapter.new
-          response =
-            if @mode == :cast
-              adapter.cast(node: node, inputs: symbolize_inputs(body["inputs"] || {}))
-            else
-              adapter.call(node: node, inputs: symbolize_inputs(body["inputs"] || {}))
-            end
-
-          persist_pending_session!(response, node) if response[:status] == :pending
-
-          json_ok(serialize_agent_response(response))
-        end
-
-        def build_node(params, body)
-          reply_mode =
-            if @mode == :cast
-              :none
-            else
-              raw = body["reply_mode"]
-              raw ? raw.to_sym : :deferred
-            end
-
-          Igniter::Model::AgentNode.new(
-            id: "server-agent:#{params[:via]}:#{params[:message]}:#{@mode}",
-            name: :"server_#{params[:via]}_#{params[:message]}_#{@mode}",
-            agent_name: params[:via],
-            message_name: params[:message],
-            input_mapping: symbolize_inputs(body["inputs"] || {}).transform_keys(&:to_sym),
-            timeout: body["timeout"] || 5,
-            mode: @mode,
-            reply_mode: reply_mode
-          )
-        end
-
-        def serialize_agent_response(response)
-          data = {
-            status: response[:status].to_s,
-            output: to_json_value(response[:output]),
-            payload: to_json_value(response[:payload]),
-            agent_trace: to_json_value(response[:agent_trace]),
-            agent_session: to_json_value(response[:agent_session]),
-            message: response[:message]
-          }
-
-          if response[:deferred_result]
-            data[:deferred_result] = {
-              token: response[:deferred_result].token,
-              source_node: response[:deferred_result].source_node,
-              waiting_on: response[:deferred_result].waiting_on,
-              payload: to_json_value(response[:deferred_result].payload)
-            }
-          end
-
-          data[:error] = to_json_value(response[:error]) if response[:error]
-          data.compact
-        end
-
-        def persist_pending_session!(response, node)
-          session = normalize_pending_session(response, node)
-          return unless session
-
-          response[:agent_session] = @session_store.save(session).to_h
-        end
-
-        def normalize_pending_session(response, node)
-          raw_session = response[:agent_session] || response[:session]
-          return Igniter::Runtime::AgentSession.from_h(raw_session) if raw_session
-
-          deferred = response[:deferred_result]
-          return nil unless deferred
-
-          Igniter::Runtime::AgentSession.new(
-            token: deferred.token,
-            node_name: deferred.source_node || node.name,
-            agent_name: node.agent_name,
-            message_name: node.message_name,
-            mode: node.mode,
-            reply_mode: node.reply_mode,
-            waiting_on: deferred.waiting_on || deferred.source_node || node.name,
-            source_node: deferred.source_node || node.name,
-            trace: response[:agent_trace],
-            payload: deferred.payload || response[:payload] || {},
-            ownership: :remote
-          )
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/agent_session_handler.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class AgentSessionHandler < Base
-        def initialize(registry, store, session_store:, mode:) # rubocop:disable Lint/UnusedMethodArgument
-          super(registry, store)
-          @session_store = session_store
-          @mode = mode.to_sym
-        end
-
-        private
-
-        def handle(params:, body:)
-          require "igniter/agent"
-
-          token = params.fetch(:token).to_s
-          session = load_session(token, body)
-
-          response =
-            case @mode
-            when :continue
-              continue_session(session, body)
-            when :resume
-              resume_session(session, body)
-            else
-              raise ResolutionError, "Unsupported agent session mode '#{@mode}'"
-            end
-
-          json_ok(serialize_agent_response(response))
-        end
-
-        def load_session(token, body)
-          return @session_store.fetch(token) if @session_store.exist?(token)
-
-          raw = body["session"] || body[:session]
-          raise ResolutionError, "Agent session payload is required" unless raw
-
-          session = Igniter::Runtime::AgentSession.from_h(raw)
-          raise ResolutionError, "Agent session token mismatch for '#{token}'" unless session.token.to_s == token
-
-          @session_store.save(session)
-        end
-
-        def continue_session(session, body)
-          payload = body["payload"] || body[:payload] || {}
-          trace = body["trace"] || body[:trace]
-          token = body["token"] || body[:token]
-          waiting_on = body["waiting_on"] || body[:waiting_on]
-          request = body["request"] || body[:request]
-          reply = body["reply"] || body[:reply]
-          phase = body["phase"] || body[:phase]
-
-          continued = session.continue(
-            payload: payload,
-            trace: trace,
-            token: token,
-            waiting_on: waiting_on,
-            request: request,
-            reply: reply,
-            phase: phase
-          )
-          @session_store.save(continued)
-
-          {
-            status: :pending,
-            message: "continue",
-            payload: continued.payload,
-            agent_trace: continued.trace,
-            agent_session: continued.to_h,
-            deferred_result: Igniter::Runtime::DeferredResult.build(
-              token: continued.token,
-              payload: continued.payload,
-              source_node: continued.source_node || continued.node_name,
-              waiting_on: continued.waiting_on
-            )
-          }
-        end
-
-        def resume_session(session, body)
-          trace = body["trace"] || body[:trace]
-          reply = body["reply"] || body[:reply]
-          value = if body.is_a?(Hash) && (body.key?("value") || body.key?(:value))
-                    body["value"] || body[:value]
-                  else
-                    nil
-                  end
-
-          completed = session.complete(value: value, reply: reply, trace: trace)
-          @session_store.delete(session.token)
-
-          {
-            status: :succeeded,
-            output: value,
-            agent_trace: completed.trace,
-            agent_session: completed.to_h
-          }
-        end
-
-        def serialize_agent_response(response)
-          data = {
-            status: response[:status].to_s,
-            output: to_json_value(response[:output]),
-            payload: to_json_value(response[:payload]),
-            agent_trace: to_json_value(response[:agent_trace]),
-            agent_session: to_json_value(response[:agent_session]),
-            message: response[:message]
-          }
-
-          if response[:deferred_result]
-            data[:deferred_result] = {
-              token: response[:deferred_result].token,
-              source_node: response[:deferred_result].source_node,
-              waiting_on: response[:deferred_result].waiting_on,
-              payload: to_json_value(response[:deferred_result].payload)
-            }
-          end
-
-          data.compact
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/base.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Igniter
-  module Server
-    module Handlers
-      class Base
-        def initialize(registry, store)
-          @registry = registry
-          @store    = store
-        end
-
-        def call(params:, body:)
-          handle(params: params, body: body)
-        rescue Igniter::Server::Registry::RegistryError => e
-          json_error(e.message, status: 404)
-        rescue Igniter::Error => e
-          json_error(e.message, status: 422)
-        rescue StandardError => e
-          json_error("Internal server error: #{e.message}", status: 500)
-        end
-
-        private
-
-        def handle(params:, body:)
-          raise NotImplementedError, "#{self.class}#handle must be implemented"
-        end
-
-        def json_ok(data)
-          { status: 200, body: JSON.generate(data), headers: json_ct }
-        end
-
-        def json_error(message, status: 422)
-          { status: status, body: JSON.generate({ error: message }), headers: json_ct }
-        end
-
-        def json_ct
-          { "Content-Type" => "application/json" }
-        end
-
-        # Serialize a contract execution result into the standard API response hash.
-        # Reads the cache directly to avoid calling contract.pending?/failed? which
-        # internally re-invoke resolve_all and would re-raise on failed nodes.
-        def serialize_execution(contract, contract_class) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          execution_id = contract.execution.events.execution_id
-          cache_values = contract.execution.cache.values
-
-          if cache_values.any?(&:pending?)
-            pending_nodes = cache_values.select(&:pending?)
-            waiting_for   = pending_nodes.filter_map { |s| s.value.payload[:event]&.to_s }
-            { execution_id: execution_id, status: "pending", waiting_for: waiting_for }
-          elsif cache_values.any?(&:failed?)
-            error_state = cache_values.find(&:failed?)
-            { execution_id: execution_id, status: "failed",
-              error: serialize_error(error_state&.error) }
-          else
-            outputs = serialize_outputs(contract, contract_class)
-            { execution_id: execution_id, status: "succeeded", outputs: outputs }
-          end
-        end
-
-        def serialize_outputs(contract, contract_class)
-          contract_class.compiled_graph.outputs.each_with_object({}) do |output, memo|
-            memo[output.name] = to_json_value(contract.result.public_send(output.name))
-          rescue StandardError
-            nil
-          end
-        end
-
-        def serialize_error(error)
-          return { message: "Unknown error" } unless error
-
-          {
-            type: error.class.name,
-            message: error.message,
-            node: error.context[:node_name]
-          }
-        end
-
-        # Recursively convert a value into JSON-safe primitives.
-        def to_json_value(value) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-          case value
-          when Hash
-            value.each_with_object({}) { |(k, v), h| h[k.to_s] = to_json_value(v) }
-          when Array
-            value.map { |v| to_json_value(v) }
-          when String, Integer, Float, TrueClass, FalseClass, NilClass
-            value
-          when Symbol
-            value.to_s
-          else
-            value.respond_to?(:to_h) ? to_json_value(value.to_h) : value.to_s
-          end
-        end
-
-        def symbolize_inputs(hash)
-          return {} unless hash.is_a?(Hash)
-
-          hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/contracts_handler.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class ContractsHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          json_ok(@registry.introspect)
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/event_handler.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class EventHandler < Base
-        def initialize(registry, store, collector: nil) # rubocop:disable Lint/UnusedMethodArgument
-          super(registry, store)
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Metrics/MethodLength
-          contract_class = @registry.fetch(params[:name])
-          event       = body["event"]&.to_sym
-          correlation = symbolize_inputs(body["correlation"] || {})
-          payload     = body["payload"] || {}
-
-          raise Igniter::Error, "event name is required" unless event
-
-          contract = contract_class.deliver_event(event,
-                                                  correlation: correlation,
-                                                  payload: payload,
-                                                  store: @store)
-          contract.resolve_all unless contract.success? || contract.failed?
-
-          json_ok(serialize_execution(contract, contract_class))
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/execute_handler.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class ExecuteHandler < Base
-        def initialize(registry, store, collector: nil)
-          super(registry, store)
-          @collector = collector
-        end
-
-        private
-
-        def handle(params:, body:)
-          contract_class = @registry.fetch(params[:name])
-          inputs = symbolize_inputs(body["inputs"] || {})
-          contract = run_contract(contract_class, inputs)
-          json_ok(serialize_execution(contract, contract_class))
-        end
-
-        def run_contract(contract_class, inputs) # rubocop:disable Metrics/MethodLength
-          if use_distributed_start?(contract_class)
-            contract_class.start(inputs, store: @store)
-          else
-            contract = contract_class.new(inputs)
-            contract.execution.events.subscribe(@collector) if @collector
-            begin
-              contract.resolve_all
-            rescue Igniter::Error
-              nil # failed state is already written to cache; serialize_execution handles it
-            end
-            contract
-          end
-        end
-
-        # Use .start for contracts that declare correlate_by (distributed workflows).
-        def use_distributed_start?(contract_class)
-          contract_class.respond_to?(:correlation_keys) && !contract_class.correlation_keys.empty?
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/health_handler.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      class HealthHandler < Base
-        def initialize(registry, store, node_url: nil)
-          super(registry, store)
-          @node_url = node_url
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/MethodLength
-          pending_count = begin
-            @store.list_pending.size
-          rescue StandardError
-            0
-          end
-
-          json_ok({
-                    status: "ok",
-                    node: @node_url,
-                    contracts: @registry.names,
-                    store: @store.class.name.split("::").last,
-                    pending: pending_count
-                  })
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/liveness_handler.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      # GET /v1/live — Kubernetes liveness probe.
-      #
-      # Returns 200 as long as the process is running. This endpoint should
-      # NEVER return a non-200 status unless the process is truly broken (e.g.
-      # deadlocked). A failing liveness probe causes K8s to restart the pod.
-      class LivenessHandler < Base
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          json_ok({ status: "alive", pid: Process.pid })
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/manifest_handler.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    module Handlers
-      # Returns a JSON manifest describing this peer: its name, advertised
-      # capabilities, registered contracts, and its base URL.
-      # Used by Igniter::Cluster::Mesh::Router health-probing and peer discovery.
-      class ManifestHandler < Base
-        def initialize(registry, store, config: nil)
-          super(registry, store)
-          @config = config
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          return json_ok({}) unless @config
-
-          identity = @config.ensure_peer_identity!
-          metadata = if defined?(Igniter::Cluster::Mesh::PeerMetadata)
-                       Igniter::Cluster::Mesh::PeerMetadata.authoritative(
-                         @config.peer_metadata || {},
-                         origin: @config.peer_name
-                       )
-                     else
-                       @config.peer_metadata || {}
-                     end
-          metadata = attach_governance(metadata)
-
-          manifest = Igniter::Cluster::Identity::Manifest.build(
-            identity: identity,
-            peer_name: @config.peer_name,
-            url: node_url,
-            capabilities: @config.peer_capabilities || [],
-            tags: @config.peer_tags || [],
-            metadata: metadata,
-            contracts: @registry.names
-          )
-
-          json_ok(manifest.to_h)
-        end
-
-        def node_url
-          return nil unless @config
-
-          "http://#{@config.host}:#{@config.port}"
-        end
-
-        def attach_governance(metadata)
-          return metadata unless defined?(Igniter::Cluster::Mesh)
-
-          mesh_config = Igniter::Cluster::Mesh.config
-          return metadata unless mesh_config.peer_name == @config.peer_name
-
-          checkpoint = mesh_config.governance_checkpoint(limit: 10)
-          metadata.merge(
-            mesh_governance: {
-              node_id: checkpoint.node_id,
-              peer_name: checkpoint.peer_name,
-              fingerprint: checkpoint.fingerprint,
-              checkpointed_at: checkpoint.checkpointed_at,
-              crest_digest: checkpoint.crest_digest,
-              checkpoint: checkpoint.to_h,
-              trust: Igniter::Cluster::Trust::Verifier.assess_governance_checkpoint(
-                checkpoint,
-                trust_store: mesh_config.trust_store
-              ).to_h
-            }
-          )
-        rescue StandardError
-          metadata
-        end
-      end
-    end
-  end
-end

data/packages/igniter-server/lib/igniter/server/handlers/metrics_handler.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/metrics"
-
-module Igniter
-  module Server
-    module Handlers
-      # GET /v1/metrics — Prometheus text format metrics endpoint.
-      #
-      # Requires a Collector to be configured on the server:
-      #   Igniter::Server.configure { |c| c.metrics_collector = Igniter::Metrics::Collector.new }
-      #
-      # When no collector is configured, returns a 501 Not Implemented response.
-      class MetricsHandler < Base
-        def initialize(registry, store, collector:)
-          super(registry, store)
-          @collector = collector
-        end
-
-        # Override Base#call to return Prometheus text/plain instead of JSON.
-        def call(params:, body:)
-          handle(params: params, body: body)
-        rescue StandardError => e
-          { status: 500,
-            body: "# ERROR: #{e.message}\n",
-            headers: { "Content-Type" => Igniter::Metrics::PrometheusExporter::CONTENT_TYPE } }
-        end
-
-        private
-
-        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          unless @collector
-            return { status: 501,
-                     body: JSON.generate({ error: "metrics_collector not configured" }),
-                     headers: { "Content-Type" => "application/json" } }
-          end
-
-          exporter = Igniter::Metrics::PrometheusExporter.new(
-            @collector,
-            store: @store,
-            registry: @registry
-          )
-
-          { status: 200,
-            body: exporter.export,
-            headers: { "Content-Type" => exporter.content_type } }
-        end
-      end
-    end
-  end
-end