igniter 0.4.5 → 0.5.1

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

@@ -0,0 +1,107 @@
+# 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

@@ -0,0 +1,125 @@
+# 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/{lib → packages/igniter-server/lib}/igniter/server/handlers/event_handler.rb

@@ -4,6 +4,10 @@ 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

data/{lib → packages/igniter-server/lib}/igniter/server/handlers/execute_handler.rb

@@ -4,6 +4,11 @@ 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:)
@@ -18,6 +23,7 @@ module Igniter
             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

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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,51 @@
+# 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

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Igniter
+  module Server
+    module Handlers
+      # Shared helper — merges static (add_peer) and dynamic (PeerRegistry) peer pools.
+      # Static entries take precedence when the same name appears in both pools.
+      module MeshPeersMerger
+        private
+
+        def merged_peers
+          return [] unless defined?(Igniter::Cluster::Mesh)
+
+          static  = Igniter::Cluster::Mesh.config.peers
+          dynamic = Igniter::Cluster::Mesh.config.peer_registry.all
+          seen    = static.each_with_object({}) { |p, h| h[p.name] = true }
+          static + dynamic.reject { |p| seen[p.name] }
+        end
+      end
+
+      # GET /v1/mesh/peers
+      # Returns the merged list of static + dynamically discovered peers.
+      class MeshPeersListHandler < Base
+        include MeshPeersMerger
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok(merged_peers.map do |p|
+            {
+              "name" => p.name,
+              "url" => p.url,
+              "capabilities" => p.capabilities.map(&:to_s),
+              "tags" => p.tags.map(&:to_s),
+              "metadata" => p.profile.metadata
+            }
+          end)
+        end
+      end
+
+      # GET /v1/mesh/sd
+      # Returns the peer list in Prometheus HTTP SD format so that Prometheus can
+      # dynamically discover all igniter-stack scrape targets without a static target list.
+      #
+      # Response shape (one object per peer):
+      #   [{ "targets" => ["host:port"], "labels" => { "__meta_igniter_peer_name" => ..., ... } }]
+      #
+      # Usage in prometheus.yml:
+      #   scrape_configs:
+      #     - job_name: igniter
+      #       http_sd_configs:
+      #         - url: http://any-seed:4567/v1/mesh/sd
+      #           refresh_interval: 30s
+      #       metrics_path: /v1/metrics
+      class MeshSdHandler < Base
+        include MeshPeersMerger
+
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          json_ok(merged_peers.map { |p| sd_entry(p) })
+        end
+
+        def sd_entry(peer)
+          {
+            "targets" => [host_port(peer.url)],
+            "labels" => {
+              "__meta_igniter_peer_name" => peer.name,
+              "__meta_igniter_capabilities" => peer.capabilities.map(&:to_s).join(","),
+              "__meta_igniter_tags" => peer.tags.map(&:to_s).join(",")
+            }
+          }
+        end
+
+        def host_port(url)
+          uri = URI.parse(url)
+          "#{uri.host}:#{uri.port}"
+        rescue URI::InvalidURIError
+          url
+        end
+      end
+
+      # POST /v1/mesh/peers
+      # Body: { "name": "peer-name", "url": "http://host:port", "capabilities": ["a", "b"], "tags": ["linux"] }
+      class MeshPeersRegisterHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument, Metrics/AbcSize
+          return json_error("Igniter::Cluster::Mesh is not loaded", status: 422) unless defined?(Igniter::Cluster::Mesh)
+
+          attributes = Igniter::Cluster::Mesh::PeerIdentityEnvelope.build(
+            source: body,
+            trust_store: Igniter::Cluster::Mesh.config.trust_store
+          )
+
+          name = attributes[:name].to_s.strip
+          url = attributes[:url].to_s.strip
+          return json_error("name is required", status: 400) if name.empty?
+          return json_error("url is required",  status: 400) if url.empty?
+
+          peer = Igniter::Cluster::Mesh::Peer.new(
+            name: name,
+            url: url,
+            capabilities: attributes[:capabilities] || [],
+            tags: attributes[:tags] || [],
+            metadata: attributes[:metadata] || {}
+          )
+          Igniter::Cluster::Mesh.config.peer_registry.register(peer)
+
+          json_ok({
+                    "registered" => true,
+                    "name" => name,
+                    "trust" => peer.metadata.dig(:mesh_trust, :status)&.to_s
+                  })
+        end
+      end
+
+      # DELETE /v1/mesh/peers/:name
+      # Idempotent — no error if the peer was not registered.
+      class MeshPeersDeleteHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
+          return json_error("Igniter::Cluster::Mesh is not loaded", status: 422) unless defined?(Igniter::Cluster::Mesh)
+
+          name = params[:name].to_s
+          Igniter::Cluster::Mesh.config.peer_registry.unregister(name)
+
+          json_ok({ "unregistered" => true, "name" => name })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      # GET /v1/ready — Kubernetes readiness probe.
+      #
+      # Returns 200 when the server is ready to accept traffic:
+      #   - Store is reachable (list_pending does not raise)
+      #   - At least one contract is registered
+      #
+      # Returns 503 when the server should be removed from the load balancer
+      # rotation but NOT restarted. A failing readiness probe causes K8s to
+      # stop routing traffic to the pod without killing it.
+      class ReadinessHandler < Base
+        private
+
+        def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument,Metrics/MethodLength
+          checks = {}
+
+          # Store connectivity check
+          checks[:store] = check_store
+
+          # Contract registration check
+          checks[:contracts] = @registry.names.any? ? "ok" : "no_contracts_registered"
+
+          if checks.values.all? { |v| v == "ok" }
+            json_ok({ status: "ready", checks: checks })
+          else
+            service_unavailable({ status: "not_ready", checks: checks })
+          end
+        end
+
+        def check_store
+          @store.list_pending(graph: nil)
+          "ok"
+        rescue StandardError => e
+          "error: #{e.message}"
+        end
+
+        def service_unavailable(data)
+          { status: 503, body: JSON.generate(data), headers: { "Content-Type" => "application/json" } }
+        end
+      end
+    end
+  end
+end