igniter 0.5.0 → 0.5.1

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/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/{lib → packages/igniter-server/lib}/igniter/server/handlers/metrics_handler.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "igniter/metrics"
+require "igniter/core/metrics"
 
 module Igniter
   module Server

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

@@ -11,10 +11,10 @@ module Igniter
         private
 
         def merged_peers
-          return [] unless defined?(Igniter::Mesh)
+          return [] unless defined?(Igniter::Cluster::Mesh)
 
-          static  = Igniter::Mesh.config.peers
-          dynamic = Igniter::Mesh.config.peer_registry.all
+          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
@@ -29,14 +29,20 @@ module Igniter
 
         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) }
+            {
+              "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-server scrape targets without a static target list.
+      # 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" => ..., ... } }]
@@ -62,7 +68,8 @@ module Igniter
             "targets" => [host_port(peer.url)],
             "labels" => {
               "__meta_igniter_peer_name" => peer.name,
-              "__meta_igniter_capabilities" => peer.capabilities.map(&:to_s).join(",")
+              "__meta_igniter_capabilities" => peer.capabilities.map(&:to_s).join(","),
+              "__meta_igniter_tags" => peer.tags.map(&:to_s).join(",")
             }
           }
         end
@@ -76,23 +83,37 @@ module Igniter
       end
 
       # POST /v1/mesh/peers
-      # Body: { "name": "peer-name", "url": "http://host:port", "capabilities": ["a", "b"] }
+      # 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::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
+          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 = body["name"].to_s.strip
-          url  = body["url"].to_s.strip
+          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?
 
-          caps = Array(body["capabilities"]).map(&:to_sym)
-          peer = Igniter::Mesh::Peer.new(name: name, url: url, capabilities: caps)
-          Igniter::Mesh.config.peer_registry.register(peer)
-
-          json_ok({ "registered" => true, "name" => name })
+          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
 
@@ -102,10 +123,10 @@ module Igniter
         private
 
         def handle(params:, body:) # rubocop:disable Lint/UnusedMethodArgument
-          return json_error("Igniter::Mesh is not loaded", status: 422) unless defined?(Igniter::Mesh)
+          return json_error("Igniter::Cluster::Mesh is not loaded", status: 422) unless defined?(Igniter::Cluster::Mesh)
 
           name = params[:name].to_s
-          Igniter::Mesh.config.peer_registry.unregister(name)
+          Igniter::Cluster::Mesh.config.peer_registry.unregister(name)
 
           json_ok({ "unregistered" => true, "name" => name })
         end

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

@@ -11,6 +11,7 @@ module Igniter
       CRLF = "\r\n"
       STATUS_MESSAGES = {
         200 => "OK",
+        303 => "See Other",
         400 => "Bad Request",
         404 => "Not Found",
         422 => "Unprocessable Entity",
@@ -23,19 +24,24 @@ module Igniter
         @config       = config
         @router       = Router.new(config)
         @logger       = ServerLogger.new(format: config.log_format)
+        @config.logger ||= @logger
         @in_flight    = 0
         @in_flight_mu = Mutex.new
+        @connections  = {}
+        @connections_mu = Mutex.new
       end
 
       def start # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         @tcp_server = TCPServer.new(@config.host, @config.port)
         @running    = true
+        @shutdown_mode = nil
 
-        trap("INT")  { stop }
-        trap("TERM") { graceful_stop }
+        trap("INT")  { request_shutdown(:immediate) }
+        trap("TERM") { request_shutdown(:graceful) }
 
-        @logger.info("igniter-server started",
+        @logger.info("igniter-stack started",
                      host: @config.host, port: @config.port, pid: Process.pid)
+        run_after_start_hooks!
 
         loop do
           break unless @running
@@ -46,34 +52,51 @@ module Igniter
       rescue IOError
         # Server socket closed via stop
       ensure
-        drain_in_flight
-        @logger.info("igniter-server stopped", pid: Process.pid)
+        if @shutdown_mode == :graceful
+          @logger.info("SIGTERM received — draining",
+                       drain_timeout: @config.drain_timeout, pid: Process.pid)
+          drain_in_flight
+        elsif @shutdown_mode == :immediate
+          close_active_connections
+        end
+        @logger.info("igniter-stack stopped", pid: Process.pid)
       end
 
       def stop
-        @running = false
-        @tcp_server&.close
+        request_shutdown(:immediate)
       end
 
       def graceful_stop
-        @logger.info("SIGTERM received — draining",
-                     drain_timeout: @config.drain_timeout, pid: Process.pid)
-        @running = false
-        @tcp_server&.close
+        request_shutdown(:graceful)
       end
 
       private
 
+      def request_shutdown(mode)
+        @shutdown_mode ||= mode
+        @running = false
+        @tcp_server&.close
+      rescue IOError, Errno::EBADF
+        nil
+      end
+
       def accept_connection
         @tcp_server.accept_nonblock
       rescue IO::WaitReadable
-        IO.select([@tcp_server], nil, nil, 0.5)
+        return nil unless @running
+
+        begin
+          IO.select([@tcp_server], nil, nil, 0.5)
+        rescue IOError, Errno::EBADF
+          nil
+        end
         nil
-      rescue IOError
+      rescue IOError, Errno::EBADF
         nil
       end
 
       def handle_connection(socket) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        register_connection(socket)
         request_line = socket.gets&.chomp
         return unless request_line&.include?(" ")
 
@@ -82,13 +105,14 @@ module Igniter
         body    = read_body(socket, headers["content-length"].to_i)
 
         with_in_flight do
-          result = @router.call(http_method, path, body)
+          result = @router.call(http_method, path, body, headers: headers)
           write_response(socket, result)
           @logger.info("#{http_method} #{path}", status: result[:status])
         end
       rescue StandardError => e
         @logger.error("Connection error", error: e.message)
       ensure
+        unregister_connection(socket)
         socket.close rescue nil # rubocop:disable Style/RescueModifier
       end
 
@@ -113,6 +137,23 @@ module Igniter
         end
       end
 
+      def register_connection(socket)
+        @connections_mu.synchronize { @connections[socket.object_id] = socket }
+      end
+
+      def unregister_connection(socket)
+        @connections_mu.synchronize { @connections.delete(socket.object_id) }
+      end
+
+      def close_active_connections
+        sockets = @connections_mu.synchronize { @connections.values.dup }
+        sockets.each do |socket|
+          socket.close
+        rescue IOError, Errno::EBADF
+          nil
+        end
+      end
+
       def read_headers(socket)
         headers = {}
         while (line = socket.gets&.chomp) && !line.empty?
@@ -127,13 +168,19 @@ module Igniter
       end
 
       def write_response(socket, result) # rubocop:disable Metrics/MethodLength
+        return write_stream_response(socket, result) if result[:stream]
+
         body   = result[:body].to_s
         code   = result[:status].to_i
         phrase = STATUS_MESSAGES.fetch(code, "Unknown")
-        ct     = result.dig(:headers, "Content-Type") || "application/json"
+        headers = (result[:headers] || {}).dup
+        ct     = headers.delete("Content-Type") || "application/json"
 
         response  = "HTTP/1.1 #{code} #{phrase}#{CRLF}"
         response += "Content-Type: #{ct}#{CRLF}"
+        headers.each do |key, value|
+          response += "#{key}: #{value}#{CRLF}"
+        end
         response += "Content-Length: #{body.bytesize}#{CRLF}"
         response += "Connection: close#{CRLF}"
         response += CRLF
@@ -141,6 +188,35 @@ module Igniter
 
         socket.write(response)
       end
+
+      def write_stream_response(socket, result)
+        code = result[:status].to_i
+        phrase = STATUS_MESSAGES.fetch(code, "Unknown")
+        headers = result[:headers] || {}
+
+        response = +"HTTP/1.1 #{code} #{phrase}#{CRLF}"
+        headers.each do |key, value|
+          response << "#{key}: #{value}#{CRLF}"
+        end
+        response << "Connection: close#{CRLF}"
+        response << CRLF
+
+        socket.write(response)
+        Array(result[:body]).each { |chunk| socket.write(chunk.to_s) } unless result[:body].respond_to?(:each)
+        return unless result[:body].respond_to?(:each)
+
+        result[:body].each do |chunk|
+          socket.write(chunk.to_s)
+        end
+      end
+
+      def run_after_start_hooks!
+        Array(@config.after_start_hooks).each do |hook|
+          hook.call(config: @config, server: self)
+        end
+      rescue StandardError => e
+        @logger.error("after_start hook failed", error: e.message)
+      end
     end
   end
 end

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

@@ -3,7 +3,7 @@
 module Igniter
   module Server
     # Rack-compatible application adapter.
-    # Allows igniter-server to run under any Rack-compatible server (Puma, Unicorn, etc.).
+    # Allows igniter-stack to run under any Rack-compatible server (Puma, Unicorn, etc.).
     #
     # Usage in config.ru:
     #   require "igniter/server"
@@ -11,6 +11,7 @@ module Igniter
     #   run Igniter::Server.rack_app
     class RackApp
       def initialize(config)
+        config.logger ||= ServerLogger.new(format: config.log_format)
         @router = Router.new(config)
       end
 
@@ -19,7 +20,15 @@ module Igniter
         path     = env["PATH_INFO"]
         body_str = env["rack.input"].read
 
-        result = @router.call(method, path, body_str)
+        result = @router.call(method, path, body_str, headers: request_headers(env), env: env)
+
+        if result[:stream]
+          return [
+            result[:status],
+            result[:headers],
+            result[:body]
+          ]
+        end
 
         [
           result[:status],
@@ -30,6 +39,22 @@ module Igniter
         error_body = JSON.generate({ error: "Internal server error: #{e.message}" })
         [500, { "Content-Type" => "application/json" }, [error_body]]
       end
+
+      private
+
+      def request_headers(env)
+        env.each_with_object({}) do |(key, value), memo|
+          case key
+          when /\AHTTP_(.+)\z/
+            name = Regexp.last_match(1).split("_").map(&:capitalize).join("-")
+            memo[name] = value
+          when "CONTENT_TYPE"
+            memo["Content-Type"] = value
+          when "CONTENT_LENGTH"
+            memo["Content-Length"] = value
+          end
+        end
+      end
     end
   end
 end

data/packages/igniter-server/lib/igniter/server/remote_adapter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    # HTTP/mesh transport adapter for Runtime remote nodes.
+    class RemoteAdapter < Igniter::Runtime::RemoteAdapter
+      def call(node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
+        url = resolve_url(node)
+        Client.new(url, timeout: node.timeout).execute(node.contract_name, inputs: inputs)
+      rescue Client::ConnectionError => e
+        raise ResolutionError, "Cannot reach #{url}: #{e.message}"
+      end
+
+      private
+
+      def resolve_url(node)
+        case node.routing_mode
+        when :static
+          node.node_url
+        else
+          raise ResolutionError,
+                "remote :#{node.name} uses #{node.routing_mode} routing — add `require 'igniter/cluster'`"
+        end
+      end
+    end
+  end
+end