igniter 0.5.0 → 0.5.1

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

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "json"
+require "stringio"
+require "uri"
+
+module Igniter
+  module Server
+    # Transport-agnostic HTTP router.
+    # Receives (method, path, body_string) and returns { status:, body:, headers: }.
+    # Used by both HttpServer (TCPServer) and RackApp.
+    class Router
+      ROUTES = [
+        { method: "GET",    pattern: %r{\A/v1/live\z},                             handler: :liveness },
+        { method: "GET",    pattern: %r{\A/v1/ready\z},                            handler: :readiness },
+        { method: "GET",    pattern: %r{\A/v1/metrics\z},                          handler: :metrics },
+        { method: "GET",    pattern: %r{\A/v1/health\z},                           handler: :health },
+        { method: "GET",    pattern: %r{\A/v1/manifest\z},                         handler: :manifest },
+        { method: "GET",    pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_list },
+        { method: "GET",    pattern: %r{\A/v1/mesh/sd\z}, handler: :mesh_sd },
+        { method: "POST",   pattern: %r{\A/v1/mesh/peers\z},                       handler: :mesh_peers_register },
+        { method: "DELETE", pattern: %r{\A/v1/mesh/peers/(?<name>.+)\z},           handler: :mesh_peers_delete },
+        { method: "GET",    pattern: %r{\A/v1/contracts\z},                        handler: :contracts },
+        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/execute\z}, handler: :execute },
+        { method: "POST",   pattern: %r{\A/v1/contracts/(?<name>[^/]+)/events\z},  handler: :event },
+        { method: "POST",   pattern: %r{\A/v1/agents/(?<via>[^/]+)/messages/(?<message>[^/]+)/call\z}, handler: :agent_call },
+        { method: "POST",   pattern: %r{\A/v1/agents/(?<via>[^/]+)/messages/(?<message>[^/]+)/cast\z}, handler: :agent_cast },
+        { method: "POST",   pattern: %r{\A/v1/agent-sessions/(?<token>[^/]+)/continue\z}, handler: :agent_session_continue },
+        { method: "POST",   pattern: %r{\A/v1/agent-sessions/(?<token>[^/]+)/resume\z}, handler: :agent_session_resume },
+        { method: "GET",    pattern: %r{\A/v1/executions/(?<id>[^/]+)\z},          handler: :status }
+      ].freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Main dispatch entry point — called by both HttpServer and RackApp.
+      # Records HTTP metrics when a collector is configured.
+      def call(http_method, path, body_str, headers: {}, env: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        started_at = Time.now.utc
+        method_uc  = http_method.to_s.upcase
+        normalized_path = normalize_path(path)
+        body = parse_body(body_str, headers)
+
+        custom_result = dispatch_custom_route(
+          method_uc,
+          normalized_path,
+          body,
+          headers: headers,
+          env: env,
+          raw_body: body_str,
+          raw_path: path
+        )
+        if custom_result
+          record_http_metric(method_uc, normalized_path, custom_result[:status], started_at)
+          return custom_result
+        end
+
+        ROUTES.each do |route|
+          next unless route[:method] == method_uc
+
+          match = route[:pattern].match(normalized_path)
+          next unless match
+
+          params  = match.named_captures.transform_keys(&:to_sym)
+          handler = build_handler(route[:handler])
+          result  = handler.call(params: params, body: body)
+
+          record_http_metric(method_uc, normalized_path, result[:status], started_at)
+          return result
+        end
+
+        result = not_found_response(normalized_path)
+        record_http_metric(method_uc, normalized_path, 404, started_at)
+        result
+      rescue JSON::ParserError => e
+        { status: 400, body: JSON.generate({ error: "Invalid JSON: #{e.message}" }), headers: json_ct }
+      end
+
+      private
+
+      def build_handler(key) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+        registry  = @config.registry
+        store     = @config.store
+        node_url  = "http://#{@config.host}:#{@config.port}"
+        collector = @config.metrics_collector
+
+        case key
+        when :liveness           then Handlers::LivenessHandler.new(registry, store)
+        when :readiness          then Handlers::ReadinessHandler.new(registry, store)
+        when :metrics            then Handlers::MetricsHandler.new(registry, store, collector: collector)
+        when :health             then Handlers::HealthHandler.new(registry, store, node_url: node_url)
+        when :manifest           then Handlers::ManifestHandler.new(registry, store, config: @config)
+        when :mesh_peers_list    then Handlers::MeshPeersListHandler.new(registry, store)
+        when :mesh_sd            then Handlers::MeshSdHandler.new(registry, store)
+        when :mesh_peers_register then Handlers::MeshPeersRegisterHandler.new(registry, store)
+        when :mesh_peers_delete  then Handlers::MeshPeersDeleteHandler.new(registry, store)
+        when :contracts          then Handlers::ContractsHandler.new(registry, store)
+        when :execute            then Handlers::ExecuteHandler.new(registry, store, collector: collector)
+        when :event              then Handlers::EventHandler.new(registry, store, collector: collector)
+        when :agent_call         then Handlers::AgentMessageHandler.new(registry, store, session_store: @config.agent_session_store, mode: :call)
+        when :agent_cast         then Handlers::AgentMessageHandler.new(registry, store, session_store: @config.agent_session_store, mode: :cast)
+        when :agent_session_continue then Handlers::AgentSessionHandler.new(registry, store, session_store: @config.agent_session_store, mode: :continue)
+        when :agent_session_resume then Handlers::AgentSessionHandler.new(registry, store, session_store: @config.agent_session_store, mode: :resume)
+        when :status             then Handlers::StatusHandler.new(registry, store)
+        end
+      end
+
+      def dispatch_custom_route(method, path, body, headers:, env:, raw_body:, raw_path:)
+        request_env = normalized_request_env(method, path, raw_path, headers, raw_body, env)
+
+        Array(@config.custom_routes).each do |route|
+          next unless route[:method] == method
+
+          params = match_custom_path(route[:path], path)
+          next unless params
+
+          request = {
+            method: method,
+            path: path,
+            params: params,
+            body: body,
+            headers: headers,
+            env: request_env,
+            raw_body: raw_body,
+            config: @config,
+            route: route
+          }
+
+          Array(@config.before_request_hooks).each { |hook| hook.call(request: request) }
+
+          result = build_custom_route_pipeline(request).call
+          response = coerce_custom_result(result)
+
+          Array(@config.after_request_hooks).each do |hook|
+            hook.call(request: request, response: response)
+          end
+
+          return response
+        end
+
+        nil
+      end
+
+      def normalized_request_env(method, path, raw_path, headers, raw_body, env)
+        query_string = raw_path.to_s.split("?", 2)[1].to_s
+        normalized_headers = headers.to_h.each_with_object({}) do |(key, value), memo|
+          canonical_key = key.to_s
+          next if canonical_key.empty?
+
+          env_key =
+            case canonical_key.downcase
+            when "content-type"
+              "CONTENT_TYPE"
+            when "content-length"
+              "CONTENT_LENGTH"
+            else
+              "HTTP_#{canonical_key.upcase.tr("-", "_")}"
+            end
+
+          memo[env_key] = value.to_s
+        end
+
+        {
+          "REQUEST_METHOD" => method.to_s.upcase,
+          "PATH_INFO" => normalize_path(path),
+          "QUERY_STRING" => query_string,
+          "rack.input" => StringIO.new(raw_body.to_s)
+        }.merge(normalized_headers).merge(env.to_h)
+      end
+
+      def build_custom_route_pipeline(request)
+        route = request.fetch(:route)
+        handler_call = lambda do
+          route.fetch(:handler).call(
+            params: request[:params],
+            body: request[:body],
+            headers: request[:headers],
+            env: request[:env],
+            raw_body: request[:raw_body],
+            config: request[:config]
+          )
+        end
+
+        Array(@config.around_request_hooks).reverse_each.reduce(handler_call) do |inner, hook|
+          lambda do
+            hook.call(request: request, &inner)
+          end
+        end
+      end
+
+      def match_custom_path(pattern, path)
+        case pattern
+        when String
+          pattern == path ? {} : nil
+        when Regexp
+          match = pattern.match(path)
+          match ? match.named_captures.transform_keys(&:to_sym) : nil
+        else
+          raise ArgumentError, "Custom route path must be a String or Regexp"
+        end
+      end
+
+      def coerce_custom_result(result)
+        if custom_response_hash?(result)
+          stream = result[:stream] || result["stream"]
+          {
+            status: integer_or_default(result[:status] || result["status"], 200),
+            body: stream ? (result[:body] || result["body"]) : serialize_custom_body(result[:body] || result["body"]),
+            headers: (result[:headers] || result["headers"] || json_ct).transform_keys(&:to_s),
+            stream: !!stream
+          }
+        else
+          { status: 200, body: serialize_custom_body(result), headers: json_ct }
+        end
+      end
+
+      def custom_response_hash?(result)
+        result.is_a?(Hash) && (result.key?(:status) || result.key?("status") ||
+          result.key?(:body) || result.key?("body") || result.key?(:headers) || result.key?("headers"))
+      end
+
+      def serialize_custom_body(body)
+        case body
+        when String
+          body
+        when nil
+          ""
+        else
+          JSON.generate(body)
+        end
+      end
+
+      def integer_or_default(value, default)
+        value.nil? ? default : value.to_i
+      end
+
+      def record_http_metric(method, path, status, started_at)
+        return unless @config.metrics_collector
+
+        duration = Time.now.utc - started_at
+        @config.metrics_collector.record_http(
+          method: method, path: path, status: status, duration: duration
+        )
+      end
+
+      def parse_body(str, headers = {})
+        return {} if str.nil? || str.strip.empty?
+
+        case request_content_type(headers)
+        when "application/x-www-form-urlencoded"
+          parse_form_body(str)
+        else
+          JSON.parse(str)
+        end
+      end
+
+      def parse_form_body(str)
+        URI.decode_www_form(str).each_with_object({}) do |(key, value), memo|
+          if memo.key?(key)
+            memo[key] = Array(memo[key]) << value
+          else
+            memo[key] = value
+          end
+        end
+      end
+
+      def request_content_type(headers)
+        headers.to_h.each do |key, value|
+          next unless key.to_s.casecmp("Content-Type").zero?
+
+          return value.to_s.split(";", 2).first.strip.downcase
+        end
+
+        nil
+      end
+
+      def normalize_path(path)
+        path.to_s.split("?", 2).first
+      end
+
+      def not_found_response(path)
+        { status: 404, body: JSON.generate({ error: "Not found: #{path}" }), headers: json_ct }
+      end
+
+      def json_ct
+        { "Content-Type" => "application/json" }
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require "json"
 
 module Igniter
   module Server
-    # Minimal structured logger for igniter-server.
+    # Minimal structured logger for igniter-stack.
     #
     # format: :json  → each line is a JSON object (Loki/ELK/CloudWatch compatible)
     # format: :text  → human-readable single-line string
@@ -34,6 +34,8 @@ module Igniter
       def log(level, message, context)
         line = @format == :json ? json_line(level, message, context) : text_line(level, message, context)
         @mutex.synchronize { @out.puts(line) }
+      rescue ThreadError
+        @out.puts(line)
       end
 
       def json_line(level, message, context)

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

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require "igniter"
+require "igniter/core/errors"
+require "igniter/core/contract"
+require "igniter/core/runtime"
+require "igniter/sdk"
 require "json"
 
 # Define the top-level Server module and Error class first,
@@ -18,11 +21,16 @@ require_relative "server/router"
 require_relative "server/http_server"
 require_relative "server/rack_app"
 require_relative "server/client"
+require_relative "server/agent_session_store"
+require_relative "server/remote_adapter"
+require_relative "server/agent_transport"
 require_relative "server/handlers/base"
 require_relative "server/handlers/health_handler"
 require_relative "server/handlers/contracts_handler"
 require_relative "server/handlers/execute_handler"
 require_relative "server/handlers/event_handler"
+require_relative "server/handlers/agent_message_handler"
+require_relative "server/handlers/agent_session_handler"
 require_relative "server/handlers/status_handler"
 require_relative "server/handlers/liveness_handler"
 require_relative "server/handlers/readiness_handler"
@@ -33,6 +41,51 @@ require_relative "server/handlers/peers_handler"
 module Igniter
   module Server
     class << self
+      def remote_adapter
+        @remote_adapter ||= RemoteAdapter.new
+      end
+
+      def agent_transport
+        @agent_transport ||= AgentTransport.new
+      end
+
+      def agent_adapter
+        require "igniter/agent"
+        Igniter::Runtime::ProxyAgentAdapter.new(
+          local_adapter: Igniter::Runtime::RegistryAgentAdapter.new,
+          transport: agent_transport
+        )
+      end
+
+      def activate_remote_adapter!
+        Igniter::Runtime.remote_adapter = remote_adapter
+      end
+
+      def activate_agent_adapter!
+        Igniter::Runtime.agent_adapter = agent_adapter
+      end
+
+      def deactivate_remote_adapter!
+        Igniter::Runtime.remote_adapter = Igniter::Runtime::RemoteAdapter.new
+      end
+
+      def deactivate_agent_adapter!
+        require "igniter/agent"
+        Igniter::Runtime.agent_adapter = Igniter::Runtime::RegistryAgentAdapter.new
+      end
+
+      def use(*names)
+        resolved_names = names.flatten.map(&:to_sym)
+        Igniter::SDK.activate!(*resolved_names, layer: :server)
+        @sdk_capabilities ||= []
+        @sdk_capabilities |= resolved_names
+        self
+      end
+
+      def sdk_capabilities
+        @sdk_capabilities ||= []
+      end
+
       def config
         @config ||= Config.new
       end
@@ -44,12 +97,16 @@ module Igniter
 
       # Start the built-in HTTP server (blocking).
       def start(**options)
+        activate_remote_adapter!
+        activate_agent_adapter!
         apply_options!(options)
         HttpServer.new(config).start
       end
 
       # Return a Rack-compatible application for use with Puma/Unicorn/etc.
       def rack_app
+        activate_remote_adapter!
+        activate_agent_adapter!
         RackApp.new(config)
       end
 

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "igniter/server"