igniter 0.5.1 → 0.5.2

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/core/errors"
-
-module Igniter
-  module SDK
-    Capability = Struct.new(:name, :entrypoint, :allowed_layers, :provides_capabilities, keyword_init: true)
-
-    class Error < Igniter::Error; end
-    class UnknownCapabilityError < Error; end
-    class LayerViolationError < Error; end
-
-    class << self
-      def register(name, entrypoint:, allowed_layers:, provides_capabilities: [])
-        capability = Capability.new(
-          name: name.to_sym,
-          entrypoint: entrypoint.to_s,
-          allowed_layers: Array(allowed_layers).map(&:to_sym).uniq.freeze,
-          provides_capabilities: Array(provides_capabilities).map(&:to_sym).uniq.sort.freeze
-        )
-
-        registry[capability.name] = capability
-      end
-
-      def fetch(name)
-        registry.fetch(name.to_sym)
-      rescue KeyError
-        available = registry.keys.sort.map(&:inspect).join(", ")
-        raise UnknownCapabilityError, "Unknown SDK capability #{name.inspect} (available: #{available})"
-      end
-
-      def capabilities(layer: nil)
-        values = registry.values
-        return values.sort_by(&:name) unless layer
-
-        values.select { |capability| capability.allowed_layers.include?(layer.to_sym) }.sort_by(&:name)
-      end
-
-      def activate!(*names, layer:)
-        resolved_layer = layer.to_sym
-
-        names.flatten.each do |name|
-          capability = fetch(name)
-          unless capability.allowed_layers.include?(resolved_layer)
-            raise LayerViolationError,
-                  "SDK capability #{capability.name.inspect} is not allowed for layer #{resolved_layer.inspect} " \
-                  "(allowed: #{capability.allowed_layers.map(&:inspect).join(', ')})"
-          end
-
-          require capability.entrypoint
-          activated_capabilities << capability.name unless activated?(capability.name)
-        end
-
-        true
-      end
-
-      def activated?(name)
-        activated_capabilities.include?(name.to_sym)
-      end
-
-      def activated_capabilities
-        @activated_capabilities ||= []
-      end
-
-      def reset!
-        @activated_capabilities = []
-      end
-
-      def register_builtin_capabilities!
-        register(:ai, entrypoint: "igniter/ai", allowed_layers: %i[app server cluster], provides_capabilities: %i[network external_api])
-        register(:agents, entrypoint: "igniter/agents", allowed_layers: %i[app server cluster], provides_capabilities: [])
-        register(:channels, entrypoint: "igniter/sdk/channels", allowed_layers: %i[app server cluster], provides_capabilities: %i[messaging network])
-        register(:tools, entrypoint: "igniter/sdk/tools", allowed_layers: %i[app server cluster], provides_capabilities: %i[filesystem])
-        register(:data, entrypoint: "igniter/sdk/data", allowed_layers: %i[core app server cluster], provides_capabilities: %i[cache database])
-      end
-
-      private
-
-      def registry
-        @registry ||= {}
-      end
-    end
-
-    register_builtin_capabilities!
-  end
-end

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

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

data/packages/igniter-server/README.md

@@ -1,9 +0,0 @@
-# igniter-server
-
-Local monorepo gem for Igniter's built-in HTTP server transport layer.
-
-Docs:
-
-- [Guide](../../docs/guide/README.md)
-- [App guide](../../docs/guide/app.md)
-- [Dev](../../docs/dev/README.md)

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    class AgentSessionStore
-      STORAGE_GRAPH = "__igniter_server_agent_sessions__"
-      ID_PREFIX = "agent-session:"
-
-      def initialize(store: nil)
-        @store = store
-        @sessions = {}
-        @mutex = Mutex.new
-      end
-
-      def save(session)
-        normalized = normalize_session(session)
-        if runtime_store
-          runtime_store.save(
-            {
-              execution_id: storage_id(normalized.token),
-              graph: STORAGE_GRAPH,
-              token: normalized.token,
-              session: normalized.to_h
-            },
-            graph: STORAGE_GRAPH,
-            correlation: { token: normalized.token.to_s }
-          )
-        else
-          @mutex.synchronize { @sessions[normalized.token] = deep_copy(normalized.to_h) }
-        end
-        normalized
-      end
-
-      def fetch(token)
-        data =
-          if runtime_store
-            snapshot = runtime_store.fetch(storage_id(token))
-            snapshot[:session] || snapshot["session"]
-          else
-            @mutex.synchronize { deep_copy(@sessions.fetch(token.to_s)) }
-          end
-        Igniter::Runtime::AgentSession.from_h(data)
-      rescue KeyError
-        raise Igniter::ResolutionError, "No agent session found for token '#{token}'"
-      end
-
-      def delete(token)
-        if runtime_store
-          runtime_store.delete(storage_id(token))
-        else
-          @mutex.synchronize { @sessions.delete(token.to_s) }
-        end
-      end
-
-      def exist?(token)
-        if runtime_store
-          runtime_store.exist?(storage_id(token))
-        else
-          @mutex.synchronize { @sessions.key?(token.to_s) }
-        end
-      end
-
-      def list_tokens
-        if runtime_store
-          runtime_store.list_all(graph: STORAGE_GRAPH).map { |id| extract_token(id) }
-        else
-          @mutex.synchronize { @sessions.keys.dup }
-        end
-      end
-
-      private
-
-      def runtime_store
-        resolved = @store.respond_to?(:call) ? @store.call : @store
-        resolved if resolved&.respond_to?(:save) && resolved.respond_to?(:fetch)
-      end
-
-      def normalize_session(session)
-        return session if session.is_a?(Igniter::Runtime::AgentSession)
-
-        data = session.respond_to?(:to_h) ? session.to_h : session
-        Igniter::Runtime::AgentSession.from_h(data)
-      end
-
-      def storage_id(token)
-        "#{ID_PREFIX}#{token}"
-      end
-
-      def extract_token(storage_id)
-        storage_id.to_s.start_with?(ID_PREFIX) ? storage_id.to_s.delete_prefix(ID_PREFIX) : storage_id.to_s
-      end
-
-      def deep_copy(value)
-        Marshal.load(Marshal.dump(value))
-      end
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    # HTTP transport for remotely routed agent nodes.
-    class AgentTransport < Igniter::Runtime::AgentTransport
-      def session_lifecycle?
-        true
-      end
-
-      def call(route:, node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
-        client = Client.new(route.url, timeout: node.timeout)
-        response = client.call_agent(
-          via: node.agent_name,
-          message: node.message_name,
-          inputs: inputs,
-          timeout: node.timeout,
-          reply_mode: node.reply_mode
-        )
-
-        normalize_response(response)
-      rescue Client::ConnectionError => error
-        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
-      end
-
-      def cast(route:, node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
-        client = Client.new(route.url, timeout: node.timeout)
-        response = client.cast_agent(
-          via: node.agent_name,
-          message: node.message_name,
-          inputs: inputs,
-          timeout: node.timeout
-        )
-
-        normalize_response(response)
-      rescue Client::ConnectionError => error
-        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
-      end
-
-      def continue_session(route:, session:, payload:, execution: nil, trace: nil, token: nil, waiting_on: nil, request: nil, reply: nil, phase: nil) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument
-        client = Client.new(route.url, timeout: 5)
-        response = client.continue_agent_session(
-          token: session.token,
-          session: session.to_h,
-          payload: payload,
-          trace: trace,
-          next_token: token,
-          waiting_on: waiting_on,
-          request: request,
-          reply: reply,
-          phase: phase
-        )
-
-        normalize_response(response)
-      rescue Client::ConnectionError => error
-        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
-      end
-
-      def resume_session(route:, session:, execution: nil, value: nil) # rubocop:disable Lint/UnusedMethodArgument
-        return nil if value.nil?
-
-        client = Client.new(route.url, timeout: 5)
-        response = client.resume_agent_session(
-          token: session.token,
-          session: session.to_h,
-          value: value
-        )
-
-        normalize_response(response)
-      rescue Client::ConnectionError => error
-        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
-      end
-
-      private
-
-      def normalize_response(response)
-        normalized = response.dup
-        deferred = response[:deferred_result]
-        return normalized unless deferred.is_a?(Hash) && !deferred.empty?
-
-        normalized[:deferred_result] = Igniter::Runtime::DeferredResult.build(
-          token: value_from(deferred, :token),
-          payload: value_from(deferred, :payload) || {},
-          source_node: value_from(deferred, :source_node),
-          waiting_on: value_from(deferred, :waiting_on)
-        )
-        normalized
-      end
-
-      def value_from(hash, key)
-        hash[key] || hash[key.to_s]
-      end
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "igniter/app/app_host_pack"

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

@@ -1,256 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-require "uri"
-
-module Igniter
-  module Server
-    # HTTP client for calling remote igniter-stack nodes.
-    # Uses only stdlib (Net::HTTP + JSON), no external gems required.
-    class Client # rubocop:disable Metrics/ClassLength
-      class Error < Igniter::Server::Error; end
-      class ConnectionError < Error; end
-      class RemoteError < Error; end
-
-      def initialize(base_url, timeout: 30)
-        @base_url = base_url.chomp("/")
-        @timeout  = timeout
-      end
-
-      # Execute a contract on the remote node synchronously.
-      #
-      # Returns a symbolized hash:
-      #   { status: :succeeded, execution_id: "uuid", outputs: { result: 42 } }
-      #   { status: :failed,    execution_id: "uuid", error: { message: "..." } }
-      #   { status: :pending,   execution_id: "uuid", waiting_for: ["event"] }
-      def execute(contract_name, inputs: {})
-        response = post(
-          "/v1/contracts/#{uri_encode(contract_name)}/execute",
-          { inputs: inputs }
-        )
-        symbolize_response(response)
-      end
-
-      # Deliver an event to a pending distributed workflow on the remote node.
-      def deliver_event(contract_name, event:, correlation:, payload: {})
-        response = post(
-          "/v1/contracts/#{uri_encode(contract_name)}/events",
-          { event: event, correlation: correlation, payload: payload }
-        )
-        symbolize_response(response)
-      end
-
-      # Fetch execution status by ID.
-      def status(execution_id)
-        symbolize_response(get("/v1/executions/#{uri_encode(execution_id)}"))
-      end
-
-      # Check remote node health.
-      def health
-        get("/v1/health")
-      end
-
-      def call_agent(via:, message:, inputs: {}, timeout: 5, reply_mode: nil)
-        response = post(
-          "/v1/agents/#{uri_encode(via)}/messages/#{uri_encode(message)}/call",
-          {
-            inputs: inputs,
-            timeout: timeout,
-            reply_mode: reply_mode
-          }.compact
-        )
-        symbolize_agent_response(response)
-      end
-
-      def cast_agent(via:, message:, inputs: {}, timeout: 5)
-        response = post(
-          "/v1/agents/#{uri_encode(via)}/messages/#{uri_encode(message)}/cast",
-          {
-            inputs: inputs,
-            timeout: timeout
-          }
-        )
-        symbolize_agent_response(response)
-      end
-
-      def continue_agent_session(token:, session:, payload: {}, trace: nil, next_token: nil, waiting_on: nil, request: nil, reply: nil, phase: nil)
-        response = post(
-          "/v1/agent-sessions/#{uri_encode(token)}/continue",
-          {
-            session: session,
-            payload: payload,
-            trace: trace,
-            token: next_token,
-            waiting_on: waiting_on,
-            request: request,
-            reply: reply,
-            phase: phase
-          }.compact
-        )
-        symbolize_agent_response(response)
-      end
-
-      def resume_agent_session(token:, session:, value: nil, trace: nil, reply: nil)
-        body = {
-          session: session,
-          trace: trace,
-          reply: reply
-        }.compact
-        body[:value] = value if !value.nil? || body.empty?
-
-        response = post(
-          "/v1/agent-sessions/#{uri_encode(token)}/resume",
-          body
-        )
-        symbolize_agent_response(response)
-      end
-
-      # Fetch peer manifest: peer_name, capabilities, contracts, url.
-      def manifest
-        response = get("/v1/manifest")
-        {
-          peer_name: response["peer_name"],
-          node_id: response["node_id"],
-          algorithm: response["algorithm"],
-          public_key: response["public_key"],
-          capabilities: (response["capabilities"] || []).map(&:to_sym),
-          tags: (response["tags"] || []).map(&:to_sym),
-          metadata: response["metadata"] || {},
-          contracts: response["contracts"] || [],
-          url: response["url"],
-          capability_attestation: response["capability_attestation"],
-          signed_at: response["signed_at"],
-          signature: response["signature"]
-        }
-      end
-
-      # Fetch the list of all peers known to the remote node.
-      # Returns an Array of hashes with :name, :url, :capabilities (Array<Symbol>).
-      def list_peers
-        Array(get("/v1/mesh/peers")).map do |p|
-          {
-            name: p["name"],
-            url: p["url"],
-            capabilities: Array(p["capabilities"]).map(&:to_sym),
-            tags: Array(p["tags"]).map(&:to_sym),
-            metadata: p["metadata"] || {}
-          }
-        end
-      end
-
-      # Register this node as a peer on the remote node.
-      def register_peer(name: nil, url: nil, capabilities: [], tags: [], metadata: {}, manifest: nil)
-        body = if manifest
-                 candidate = manifest.respond_to?(:to_h) ? manifest.to_h : manifest
-                 Hash(candidate)
-               else
-                 {
-                   "name" => name,
-                   "url" => url,
-                   "capabilities" => capabilities.map(&:to_s),
-                   "tags" => tags.map(&:to_s),
-                   "metadata" => metadata
-                 }
-               end
-
-        post("/v1/mesh/peers", body)
-      end
-
-      # Remove a peer registration from the remote node. Best-effort.
-      def unregister_peer(name)
-        delete_request("/v1/mesh/peers/#{uri_encode(name)}")
-      end
-
-      private
-
-      def post(path, body)
-        uri  = build_uri(path)
-        http = build_http(uri)
-        req  = Net::HTTP::Post.new(uri.path, json_headers)
-        req.body = JSON.generate(body)
-        parse_response(http.request(req))
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
-        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
-      end
-
-      def get(path)
-        uri  = build_uri(path)
-        http = build_http(uri)
-        req  = Net::HTTP::Get.new(uri.path, json_headers)
-        parse_response(http.request(req))
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
-        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
-      end
-
-      def delete_request(path)
-        uri  = build_uri(path)
-        http = build_http(uri)
-        req  = Net::HTTP::Delete.new(uri.path, json_headers)
-        parse_response(http.request(req))
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
-        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
-      end
-
-      def build_uri(path)
-        URI.parse("#{@base_url}#{path}")
-      end
-
-      def build_http(uri)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl      = uri.scheme == "https"
-        http.read_timeout = @timeout
-        http.open_timeout = 10
-        http
-      end
-
-      def json_headers
-        { "Content-Type" => "application/json", "Accept" => "application/json" }
-      end
-
-      def parse_response(response)
-        body = begin
-          JSON.parse(response.body.to_s)
-        rescue JSON::ParserError
-          {}
-        end
-        raise RemoteError, "Remote error #{response.code}: #{body["error"]}" unless response.is_a?(Net::HTTPSuccess)
-
-        body
-      end
-
-      def symbolize_response(hash)
-        {
-          status: hash["status"]&.to_sym,
-          execution_id: hash["execution_id"],
-          outputs: symbolize_keys(hash["outputs"] || {}),
-          waiting_for: hash["waiting_for"] || [],
-          error: hash["error"]
-        }
-      end
-
-      def symbolize_agent_response(hash)
-        {
-          status: hash["status"]&.to_sym,
-          output: hash["output"],
-          payload: symbolize_keys(hash["payload"] || {}),
-          deferred_result: (symbolize_keys(hash["deferred_result"]) if hash.key?("deferred_result")),
-          agent_trace: symbolize_keys(hash["agent_trace"] || {}),
-          agent_session: (symbolize_keys(hash["agent_session"]) if hash.key?("agent_session")),
-          error: hash["error"],
-          message: hash["message"]
-        }.compact
-      end
-
-      def symbolize_keys(hash)
-        return hash unless hash.is_a?(Hash)
-
-        hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
-      end
-
-      def uri_encode(str)
-        URI.encode_uri_component(str.to_s)
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Server
-    class Config
-      attr_accessor :host, :port, :store, :logger,
-                    :metrics_collector, :log_format, :drain_timeout,
-                    :peer_name, :peer_capabilities, :peer_tags, :peer_metadata, :peer_identity, :peer_trust_store, :custom_routes,
-                    :before_request_hooks, :after_request_hooks, :around_request_hooks, :after_start_hooks,
-                    :agent_session_store
-      attr_reader   :registry
-
-      def initialize
-        @host              = "0.0.0.0"
-        @port              = 4567
-        @store             = Igniter::Runtime::Stores::MemoryStore.new
-        @agent_session_store = Igniter::Server::AgentSessionStore.new(store: -> { @store })
-        @registry          = Registry.new
-        @logger            = nil
-        @metrics_collector = nil
-        @log_format        = :text
-        @drain_timeout     = 30
-        @peer_name         = nil
-        @peer_capabilities = []
-        @peer_tags         = []
-        @peer_metadata     = {}
-        @peer_identity     = nil
-        @peer_trust_store  = nil
-        @custom_routes     = []
-        @before_request_hooks = []
-        @after_request_hooks = []
-        @around_request_hooks = []
-        @after_start_hooks = []
-      end
-
-      def ensure_peer_identity!
-        load_cluster_support!
-        @peer_identity ||= Igniter::Cluster::Identity::NodeIdentity.generate(node_id: @peer_name || "anonymous-node")
-      end
-
-      def peer_trust_store
-        @peer_trust_store ||= begin
-          load_cluster_support!
-          Igniter::Cluster::Trust::TrustStore.new
-        end
-      end
-
-      def register(name, contract_class)
-        @registry.register(name, contract_class)
-        self
-      end
-
-      def contracts=(hash)
-        hash.each { |name, klass| register(name.to_s, klass) }
-      end
-
-      private
-
-      def load_cluster_support!
-        return if defined?(Igniter::Cluster::Identity::NodeIdentity) &&
-          defined?(Igniter::Cluster::Trust::TrustStore)
-
-        require "igniter/cluster"
-      rescue LoadError => e
-        raise LoadError,
-              "Igniter::Server cluster identity support requires `igniter/cluster` (#{e.message})"
-      end
-    end
-  end
-end