lex-mesh 0.1.1 → 0.2.4

data/spec/legion/extensions/mesh/helpers/peer_verify_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ed25519'
+
+RSpec.describe Legion::Extensions::Mesh::Helpers::PeerVerify do
+  let(:signing_key) { Ed25519::SigningKey.generate }
+  let(:verify_key) { signing_key.verify_key }
+  let(:private_key_b64) { Base64.strict_encode64(signing_key.to_bytes) }
+  let(:public_key_b64) { Base64.strict_encode64(verify_key.to_bytes) }
+
+  let(:peer_config) do
+    [{ org_id: 'acme', public_key: "ed25519:#{public_key_b64}",
+       capabilities: %w[query task], rate_limit: 5 }]
+  end
+
+  before do
+    described_class.reset_counters!
+    stub_const('Legion::Settings', Module.new) unless defined?(Legion::Settings)
+    allow(Legion::Settings).to receive(:dig).with(:mesh, :trusted_peers).and_return(peer_config)
+  end
+
+  describe '.sign_message' do
+    it 'signs a payload with Ed25519' do
+      result = described_class.sign_message({ hello: 'world' }, private_key_b64)
+      expect(result[:signature]).to be_a(String)
+      expect(result[:payload]).to eq({ hello: 'world' })
+    end
+  end
+
+  describe '.verify_message' do
+    it 'verifies a validly signed message' do
+      signed = described_class.sign_message({ hello: 'world' }, private_key_b64)
+      result = described_class.verify_message(signed, org_id: 'acme')
+      expect(result[:valid]).to be true
+      expect(result[:org_id]).to eq('acme')
+    end
+
+    it 'rejects a tampered message' do
+      signed = described_class.sign_message({ hello: 'world' }, private_key_b64)
+      signed[:signed_bytes] = 'tampered data'
+      result = described_class.verify_message(signed, org_id: 'acme')
+      expect(result[:valid]).to be false
+      expect(result[:reason]).to eq(:invalid_signature)
+    end
+
+    it 'rejects unknown peers' do
+      signed = described_class.sign_message({ hello: 'world' }, private_key_b64)
+      result = described_class.verify_message(signed, org_id: 'unknown-org')
+      expect(result[:valid]).to be false
+      expect(result[:reason]).to eq(:unknown_peer)
+    end
+  end
+
+  describe '.check_rate_limit' do
+    it 'allows messages within limit' do
+      result = described_class.check_rate_limit('acme')
+      expect(result[:allowed]).to be true
+    end
+
+    it 'blocks messages over limit' do
+      5.times { described_class.check_rate_limit('acme') }
+      result = described_class.check_rate_limit('acme')
+      expect(result[:allowed]).to be false
+      expect(result[:error]).to eq(:rate_limited)
+    end
+
+    it 'resets after window expires' do
+      5.times { described_class.check_rate_limit('acme') }
+      counters = described_class.instance_variable_get(:@counters)
+      counters['acme'][:window_start] = Time.now.utc - 61
+      result = described_class.check_rate_limit('acme')
+      expect(result[:allowed]).to be true
+    end
+  end
+end

data/spec/legion/extensions/mesh/helpers/pending_requests_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/helpers/pending_requests'
+
+RSpec.describe Legion::Extensions::Mesh::Helpers::PendingRequests do
+  subject(:tracker) { described_class.new(default_ttl: 5) }
+
+  describe '#register' do
+    it 'stores a pending request' do
+      tracker.register(correlation_id: 'abc', callback: ->(_r) {})
+      expect(tracker.pending?('abc')).to be true
+    end
+
+    it 'increments pending_count' do
+      expect { tracker.register(correlation_id: 'x', callback: nil) }
+        .to change { tracker.pending_count }.by(1)
+    end
+  end
+
+  describe '#resolve' do
+    it 'invokes callback and removes entry' do
+      received = nil
+      tracker.register(correlation_id: 'r1', callback: ->(result) { received = result })
+      result = tracker.resolve(correlation_id: 'r1', result: { verbosity: :concise })
+      expect(result).to be true
+      expect(received).to eq({ verbosity: :concise })
+      expect(tracker.pending?('r1')).to be false
+    end
+
+    it 'returns false for unknown correlation_id' do
+      result = tracker.resolve(correlation_id: 'nonexistent', result: {})
+      expect(result).to be false
+    end
+
+    it 'handles nil callback gracefully' do
+      tracker.register(correlation_id: 'nil-cb', callback: nil)
+      expect { tracker.resolve(correlation_id: 'nil-cb', result: {}) }.not_to raise_error
+    end
+  end
+
+  describe '#pending?' do
+    it 'returns false for unregistered id' do
+      expect(tracker.pending?('missing')).to be false
+    end
+  end
+
+  describe '#pending_count' do
+    it 'returns correct count' do
+      tracker.register(correlation_id: 'a', callback: nil)
+      tracker.register(correlation_id: 'b', callback: nil)
+      expect(tracker.pending_count).to eq(2)
+    end
+  end
+
+  describe '#expire' do
+    it 'removes entries past TTL' do
+      tracker.register(correlation_id: 'old', callback: nil, ttl: 1)
+      entry = tracker.instance_variable_get(:@requests)['old']
+      entry[:registered_at] = Time.now - 10
+      expired = tracker.expire
+      expect(expired).to include('old')
+      expect(tracker.pending?('old')).to be false
+    end
+
+    it 'does not remove entries within TTL' do
+      tracker.register(correlation_id: 'fresh', callback: nil, ttl: 60)
+      tracker.expire
+      expect(tracker.pending?('fresh')).to be true
+    end
+
+    it 'returns array of expired correlation ids' do
+      tracker.register(correlation_id: 'e1', callback: nil, ttl: 1)
+      tracker.register(correlation_id: 'e2', callback: nil, ttl: 1)
+      tracker.instance_variable_get(:@requests).each_value { |e| e[:registered_at] = Time.now - 10 }
+      expired = tracker.expire
+      expect(expired).to contain_exactly('e1', 'e2')
+    end
+  end
+end

data/spec/legion/extensions/mesh/helpers/registry_spec.rb

@@ -272,6 +272,47 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::Registry do
     end
   end
 
+  describe '#expire_silent_agents' do
+    it 'marks stale agents as offline' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq(['a1'])
+      expect(registry.agents['a1'][:status]).to eq(:offline)
+    end
+
+    it 'does not expire agents within timeout' do
+      registry.register_agent('a1')
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq([])
+      expect(registry.agents['a1'][:status]).to eq(:online)
+    end
+
+    it 'does not expire already-offline agents' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      registry.agents['a1'][:status] = :offline
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to eq([])
+    end
+
+    it 'returns multiple expired agent ids' do
+      registry.register_agent('a1')
+      registry.register_agent('a2')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 60
+      registry.agents['a2'][:last_seen] = Time.now.utc - 60
+      expired = registry.expire_silent_agents(timeout: 30)
+      expect(expired).to contain_exactly('a1', 'a2')
+    end
+
+    it 'uses MESH_SILENCE_TIMEOUT as default' do
+      registry.register_agent('a1')
+      registry.agents['a1'][:last_seen] = Time.now.utc - 31
+      expired = registry.expire_silent_agents
+      expect(expired).to eq(['a1'])
+    end
+  end
+
   describe '#count' do
     it 'returns 0 for an empty registry' do
       expect(registry.count).to eq(0)

data/spec/legion/extensions/mesh/runners/delegation_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Mesh::Runners::Delegation do
+  subject { Object.new.extend(described_class) }
+
+  before do
+    subject.instance_variable_set(:@delegation_tracker, nil)
+  end
+
+  describe '#delegate' do
+    it 'creates a delegation' do
+      result = subject.delegate(from: 'a', to: 'b', task_context: 'task-1', consent_level: :execute)
+      expect(result[:success]).to be true
+      expect(result[:delegation_id]).to start_with('del-')
+      expect(result[:depth]).to eq(0)
+    end
+
+    it 'returns failure for depth exceeded' do
+      d1 = subject.delegate(from: 'a', to: 'b', task_context: 't', consent_level: :execute)
+      d2 = subject.delegate(from: 'b', to: 'c', task_context: 't', consent_level: :execute,
+                            parent_delegation_id: d1[:delegation_id])
+      d3 = subject.delegate(from: 'c', to: 'd', task_context: 't', consent_level: :execute,
+                            parent_delegation_id: d2[:delegation_id])
+      d4 = subject.delegate(from: 'd', to: 'e', task_context: 't', consent_level: :execute,
+                            parent_delegation_id: d3[:delegation_id])
+      expect(d4[:success]).to be false
+    end
+  end
+
+  describe '#complete_delegation' do
+    it 'completes an active delegation' do
+      d = subject.delegate(from: 'a', to: 'b', task_context: 't', consent_level: :execute)
+      result = subject.complete_delegation(delegation_id: d[:delegation_id])
+      expect(result[:success]).to be true
+    end
+
+    it 'fails for non-existent delegation' do
+      result = subject.complete_delegation(delegation_id: 'del-fake')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#revoke_delegation' do
+    it 'revokes an active delegation' do
+      d = subject.delegate(from: 'a', to: 'b', task_context: 't', consent_level: :execute)
+      result = subject.revoke_delegation(delegation_id: d[:delegation_id])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#delegation_chain' do
+    it 'returns the full chain' do
+      d1 = subject.delegate(from: 'a', to: 'b', task_context: 't', consent_level: :execute)
+      d2 = subject.delegate(from: 'b', to: 'c', task_context: 't', consent_level: :execute,
+                            parent_delegation_id: d1[:delegation_id])
+      result = subject.delegation_chain(delegation_id: d2[:delegation_id])
+      expect(result[:success]).to be true
+      expect(result[:chain].size).to eq(2)
+      expect(result[:depth]).to eq(1)
+    end
+  end
+
+  describe '#agent_delegations' do
+    it 'lists delegations for an agent' do
+      subject.delegate(from: 'a', to: 'b', task_context: 't1', consent_level: :execute)
+      subject.delegate(from: 'a', to: 'c', task_context: 't2', consent_level: :execute)
+      result = subject.agent_delegations(agent_id: 'a')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#delegation_stats' do
+    it 'returns statistics' do
+      subject.delegate(from: 'a', to: 'b', task_context: 't', consent_level: :execute)
+      result = subject.delegation_stats
+      expect(result[:success]).to be true
+      expect(result[:total]).to eq(1)
+      expect(result[:active]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/mesh/runners/mesh_spec.rb

@@ -23,6 +23,22 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Mesh do
       result = client.unregister(agent_id: 'unknown')
       expect(result[:error]).to eq(:not_found)
     end
+
+    it 'publishes mesh departure signal when transport available' do
+      client.register(agent_id: 'agent-1', capabilities: [:search])
+
+      mock_msg = instance_double('MeshDeparture', publish: nil)
+      stub_const('Legion::Extensions::Mesh::Transport::Messages::MeshDeparture', class_double('MeshDeparture', new: mock_msg))
+
+      client.unregister(agent_id: 'agent-1')
+      expect(mock_msg).to have_received(:publish)
+    end
+
+    it 'succeeds without transport available' do
+      client.register(agent_id: 'agent-1')
+      result = client.unregister(agent_id: 'agent-1')
+      expect(result[:unregistered]).to be true
+    end
   end
 
   describe '#send_message' do
@@ -65,4 +81,13 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Mesh do
       expect(status[:online]).to eq(1)
     end
   end
+
+  describe '#expire_silent_agents' do
+    it 'returns expired agent count' do
+      client.register(agent_id: 'a1')
+      result = client.expire_silent_agents
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
 end

data/spec/legion/extensions/mesh/runners/preferences_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/helpers/pending_requests'
+require 'legion/extensions/mesh/helpers/preference_profile'
+require 'legion/extensions/mesh/runners/preferences'
+
+RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
+  let(:runner) { Object.new.extend(described_class) }
+
+  describe '#query_preferences' do
+    context 'without transport' do
+      it 'returns local_default profile' do
+        result = runner.query_preferences(target_agent_id: 'agent-99')
+        expect(result[:success]).to be true
+        expect(result[:source]).to eq(:local_default)
+        expect(result[:profile]).to be_a(Hash)
+      end
+
+      it 'includes default preference keys in profile' do
+        result = runner.query_preferences(target_agent_id: 'agent-99')
+        expect(result[:profile]).to have_key(:verbosity)
+        expect(result[:profile]).to have_key(:tone)
+      end
+    end
+
+    context 'with transport available' do
+      before do
+        stub_const('Legion::Transport::Connection', Class.new do
+          def self.session; end
+        end)
+        stub_const('Legion::Extensions::Mesh::Transport::Messages::PreferenceQuery',
+                   Class.new do
+                     def initialize(**_opts); end
+
+                     def publish; end
+                   end)
+      end
+
+      it 'returns pending status with correlation_id' do
+        result = runner.query_preferences(target_agent_id: 'agent-42')
+        expect(result[:success]).to be true
+        expect(result[:source]).to eq(:pending)
+        expect(result[:correlation_id]).to be_a(String)
+        expect(result[:correlation_id]).not_to be_empty
+      end
+
+      it 'registers a pending request' do
+        result = runner.query_preferences(target_agent_id: 'agent-42')
+        pending_req = runner.send(:pending_requests)
+        expect(pending_req.pending?(result[:correlation_id])).to be true
+      end
+    end
+  end
+
+  describe '#handle_preference_query' do
+    it 'returns local profile' do
+      result = runner.handle_preference_query(requesting_agent_id: 'agent-1')
+      expect(result[:success]).to be true
+      expect(result[:profile]).to be_a(Hash)
+      expect(result[:responding_agent_id]).not_to be_nil
+    end
+
+    it 'includes verbosity in profile' do
+      result = runner.handle_preference_query(requesting_agent_id: 'agent-1')
+      expect(result[:profile]).to have_key(:verbosity)
+    end
+  end
+
+  describe '#handle_preference_response' do
+    it 'resolves a pending request' do
+      received = nil
+      pending_req = runner.send(:pending_requests)
+      pending_req.register(
+        correlation_id: 'corr-1',
+        callback:       ->(profile) { received = profile }
+      )
+      result = runner.handle_preference_response(
+        correlation_id: 'corr-1',
+        profile:        { verbosity: :concise }
+      )
+      expect(result[:resolved]).to be true
+      expect(received).to eq({ verbosity: :concise })
+    end
+
+    it 'returns false for unknown correlation_id' do
+      result = runner.handle_preference_response(
+        correlation_id: 'unknown-corr',
+        profile:        {}
+      )
+      expect(result[:resolved]).to be false
+    end
+  end
+
+  describe '#dispatch_preference_message' do
+    context 'with preference_query type' do
+      it 'calls handle_preference_query and returns profile' do
+        result = runner.dispatch_preference_message(
+          type:                'preference_query',
+          requesting_agent_id: 'agent-1',
+          correlation_id:      'corr-123'
+        )
+        expect(result[:success]).to be true
+        expect(result[:profile]).to be_a(Hash)
+      end
+    end
+
+    context 'with preference_response type' do
+      it 'resolves a pending request' do
+        pending_req = runner.send(:pending_requests)
+        pending_req.register(correlation_id: 'corr-abc', callback: ->(_p) {})
+        result = runner.dispatch_preference_message(
+          type:           'preference_response',
+          correlation_id: 'corr-abc',
+          profile:        { verbosity: :concise }
+        )
+        expect(result[:resolved]).to be true
+      end
+
+      it 'returns false for unknown correlation_id' do
+        result = runner.dispatch_preference_message(
+          type:           'preference_response',
+          correlation_id: 'unknown',
+          profile:        {}
+        )
+        expect(result[:resolved]).to be false
+      end
+    end
+
+    context 'with unknown type' do
+      it 'returns error' do
+        result = runner.dispatch_preference_message(type: 'bogus')
+        expect(result[:success]).to be false
+        expect(result[:error]).to include('unknown')
+      end
+    end
+
+    context 'with nil type' do
+      it 'returns error' do
+        result = runner.dispatch_preference_message(type: nil)
+        expect(result[:success]).to be false
+      end
+    end
+  end
+
+  describe '#expire_pending_requests' do
+    it 'cleans up expired entries and returns count' do
+      pending_req = runner.send(:pending_requests)
+      pending_req.register(correlation_id: 'old-1', callback: nil, ttl: 1)
+      pending_req.register(correlation_id: 'old-2', callback: nil, ttl: 1)
+      pending_req.instance_variable_get(:@requests).each_value { |e| e[:registered_at] = Time.now - 60 }
+
+      result = runner.expire_pending_requests
+      expect(result[:expired]).to eq(2)
+      expect(result[:correlation_ids]).to contain_exactly('old-1', 'old-2')
+    end
+
+    it 'returns zero when nothing expired' do
+      result = runner.expire_pending_requests
+      expect(result[:expired]).to eq(0)
+      expect(result[:correlation_ids]).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/mesh/transport/messages/mesh_departure_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        def initialize(**options)
+          @options = options
+        end
+      end
+    end
+  end
+end
+
+unless defined?(Legion::Transport::Exchanges::Node)
+  module Legion
+    module Transport
+      module Exchanges
+        class Node # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/messages/mesh_departure'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::MeshDeparture do
+  subject(:msg) do
+    described_class.new(
+      agent_id:     'agent-42',
+      capabilities: %i[code_review search]
+    )
+  end
+
+  describe '#exchange' do
+    it 'returns the Node exchange' do
+      expect(msg.exchange).to eq(Legion::Transport::Exchanges::Node)
+    end
+  end
+
+  describe '#routing_key' do
+    it 'uses mesh.departure' do
+      expect(msg.routing_key).to eq('mesh.departure')
+    end
+  end
+
+  describe '#message' do
+    it 'includes type mesh_departure' do
+      expect(msg.message[:type]).to eq('mesh_departure')
+    end
+
+    it 'includes agent_id' do
+      expect(msg.message[:agent_id]).to eq('agent-42')
+    end
+
+    it 'includes capabilities' do
+      expect(msg.message[:capabilities]).to eq(%i[code_review search])
+    end
+
+    it 'includes departed_at timestamp' do
+      expect(msg.message[:departed_at]).to be_a(String)
+    end
+  end
+
+  describe '#type' do
+    it 'returns mesh_departure' do
+      expect(msg.type).to eq('mesh_departure')
+    end
+  end
+
+  describe 'empty capabilities default' do
+    subject(:msg_no_caps) { described_class.new(agent_id: 'x') }
+
+    it 'defaults capabilities to empty array' do
+      expect(msg_no_caps.message[:capabilities]).to eq([])
+    end
+  end
+end

data/spec/legion/extensions/mesh/transport/messages/preference_query_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+unless defined?(Legion::Transport::Message)
+  module Legion
+    module Transport
+      class Message
+        def initialize(**options)
+          @options = options
+        end
+      end
+    end
+  end
+end
+
+unless defined?(Legion::Transport::Exchanges::Agent)
+  module Legion
+    module Transport
+      module Exchanges
+        class Agent
+          def self.name
+            'Legion::Transport::Exchanges::Agent'
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'legion/extensions/mesh/transport/messages/preference_query'
+
+RSpec.describe Legion::Extensions::Mesh::Transport::Messages::PreferenceQuery do
+  subject(:msg) do
+    described_class.new(
+      target_agent_id:     'agent-42',
+      requesting_agent_id: 'agent-1',
+      domains:             %i[verbosity tone]
+    )
+  end
+
+  describe '#exchange' do
+    it 'returns the Agent exchange' do
+      expect(msg.exchange).to eq(Legion::Transport::Exchanges::Agent)
+    end
+  end
+
+  describe '#routing_key' do
+    it 'routes to target agent' do
+      expect(msg.routing_key).to eq('agent.agent-42.preferences')
+    end
+  end
+
+  describe '#message' do
+    it 'includes type preference_query' do
+      expect(msg.message[:type]).to eq('preference_query')
+    end
+
+    it 'includes requesting_agent_id' do
+      expect(msg.message[:requesting_agent_id]).to eq('agent-1')
+    end
+
+    it 'includes domains' do
+      expect(msg.message[:domains]).to eq(%i[verbosity tone])
+    end
+
+    it 'includes requested_at timestamp' do
+      expect(msg.message[:requested_at]).to be_a(String)
+    end
+  end
+
+  describe '#type' do
+    it 'returns preference_query' do
+      expect(msg.type).to eq('preference_query')
+    end
+  end
+
+  describe 'empty domains default' do
+    subject(:msg_no_domains) { described_class.new(target_agent_id: 'x', requesting_agent_id: 'y') }
+
+    it 'defaults domains to empty array' do
+      expect(msg_no_domains.message[:domains]).to eq([])
+    end
+  end
+end