legionio 1.6.9 → 1.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e67d5abaf8c274cad673af9996e29577949a9e945c66ee099b1c8e23eeff4a3f
-  data.tar.gz: 4c3113323f086005de660cd84128036d59919ee2f2482ce84a855334bab007c4
+  metadata.gz: 33862e1884c9ba2e72a1dc6920fb32626bce8a54a3a866065ae8413f3b351639
+  data.tar.gz: 7f78f235733a55b9561d28a454f8d3d5287814b5e4ae627ee83de821ef41a4ac
 SHA512:
-  metadata.gz: d221a3d63b90d155b24fabd47594aef550467d6136a96092208a7f710455f87f416ae4110815e323c7bfcb83aec13ec4c41dff7b2db14b0846dafbe55ca9be66
-  data.tar.gz: b495e7daddcbb0e5cbda7c93f152ca285e044972ee8b74c9d432f91e97c4536d1087539f7b8daf784910cb359935453b6aa1f9e972c8d81b688d55c8986e2f34
+  metadata.gz: 04ae595b050e2790044d84c382b2f42fa2dc34516245695f75728764d0365a203636c1cbd9dffbc7f0c18ec95586f06922310f2933fa6a38e4583a0d2307c5ff
+  data.tar.gz: 6ea1841ad50f8fb26c9243ea01194576aee7813721b5a1677c0452e8aa71e99ea5788430d003ac5aa1ea910a25310b565c62b17819c77d1e24cc811260d01eea

data/CHANGELOG.md

@@ -2,7 +2,14 @@
 
 ## [Unreleased]
 
+## [1.6.11] - 2026-03-26
+
 ### Added
+- `Legion::Dispatch` module with pluggable strategy interface and `Local` implementation using `Concurrent::FixedThreadPool`
+- Local dispatch wiring in `extensions.rb`: `dispatch_local_actors` registers non-remote extensions in thread pool
+- `Ingress.local_runner?` short-circuit: runners for `remote_invocable? false` extensions skip AMQP round-trip
+- `setup_dispatch` in `Service` boot sequence with graceful shutdown
+- `legion broker stats` and `legion broker cleanup` CLI commands for RabbitMQ management
 - End-to-end integration test for TBI Phase 5 self-generating functions loop (9 examples)
 - Test dependencies: lex-codegen, lex-eval added to Gemfile for integration testing
 - Specs for `legion codegen` CLI subcommand (8 subcommands, 22 examples)
@@ -15,6 +22,15 @@
 - Move `Legion::LLM.chat` stub to `RSpec.configure before(:each)` block so it always intercepts regardless of whether the real `legion-llm` gem is loaded, preventing external LLM calls in integration tests
 - Fix `service_setup_apollo_spec` "starts Apollo::Local" example: stub `Legion::Apollo.start` to prevent internal double-call of `Apollo::Local.start`
 
+## [1.6.10] - 2026-03-26
+
+### Changed
+- `ConfigImport.write_config` now splits recognized subsystem keys (`microsoft_teams`, `rbac`, `api`, `logging`, `gaia`, `extensions`, `llm`, `data`, `cache_local`, `cache`, `transport`, `crypt`, `role`) into individual `{key}.json` files
+- Remaining unrecognized keys written to `bootstrapped_settings.json` (replaces `imported.json`)
+- Subsystem files are always overwritten on bootstrap; remainder file respects `--force` for merge behavior
+- `write_config` returns an array of written paths instead of a single path
+- `legion bootstrap` and `legion config import` updated to display per-file write confirmations
+
 ## [1.6.9] - 2026-03-26
 
 ### Added

data/lib/legion/cli/bootstrap_command.rb

@@ -63,9 +63,15 @@ module Legion
         results[:packs_requested] = pack_names
 
         # 4. Write config
-        path = ConfigImport.write_config(config, force: options[:force])
-        results[:config_written] = path
-        out.success("Config written to #{path}") unless options[:json]
+        paths = ConfigImport.write_config(config, force: options[:force])
+        results[:config_written] = paths
+        unless options[:json]
+          if paths.empty?
+            out.warn('No config files were written (config was empty after removing packs).')
+          else
+            paths.each { |p| out.success("Written: #{p}") }
+          end
+        end
 
         # 5. Scaffold missing subsystem files
         results[:scaffold] = run_scaffold(out)

data/lib/legion/cli/broker_command.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'erb'
+require 'json'
+
+module Legion
+  module CLI
+    class Broker < Thor
+      namespace 'broker'
+
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,     type: :boolean, default: false,    desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false,    desc: 'Disable color output'
+      class_option :host,     type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
+      class_option :port,     type: :numeric, default: 15_672,   desc: 'RabbitMQ management port'
+      class_option :user,     type: :string,  default: 'guest',  desc: 'RabbitMQ management username'
+      class_option :password, type: :string,  default: 'guest',  desc: 'RabbitMQ management password'
+      class_option :vhost,    type: :string,  default: '/',      desc: 'RabbitMQ vhost'
+
+      desc 'stats', 'Show RabbitMQ broker statistics (queues, exchanges, consumers, DLX)'
+      def stats
+        out = formatter
+        data = fetch_stats
+
+        if options[:json]
+          out.json(data)
+        else
+          out.header('RabbitMQ Broker Stats')
+          out.spacer
+          out.detail({
+                       queues:    data[:queues],
+                       exchanges: data[:exchanges],
+                       consumers: data[:consumers],
+                       dlx:       data[:dlx]
+                     })
+        end
+      rescue Legion::CLI::Error => e
+        formatter.error(e.message)
+        exit(1)
+      end
+
+      desc 'cleanup', 'Find (and optionally delete) orphaned queues with 0 consumers and 0 messages'
+      option :execute, type: :boolean, default: false, desc: 'Actually delete orphaned queues (default: dry-run)'
+      def cleanup
+        out = formatter
+        orphans = find_orphans
+
+        if orphans.empty?
+          out.success('No orphaned queues found')
+          return
+        end
+
+        if options[:json]
+          out.json({ orphaned_queues: orphans, deleted: options[:execute] })
+          delete_orphans(orphans) if options[:execute]
+          return
+        end
+
+        out.header("Orphaned Queues (#{orphans.size})")
+        orphans.each { |q| out.warn(q) }
+        out.spacer
+
+        if options[:execute]
+          delete_orphans(orphans)
+          out.success("Deleted #{orphans.size} orphaned queue(s)")
+        else
+          out.warn('Dry-run mode — pass --execute to delete')
+        end
+      rescue Legion::CLI::Error => e
+        formatter.error(e.message)
+        exit(1)
+      end
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def vhost_encoded
+          ERB::Util.url_encode(options[:vhost])
+        end
+
+        def management_api(path)
+          uri = URI("http://#{options[:host]}:#{options[:port]}/api#{path}")
+          req = Net::HTTP::Get.new(uri)
+          req.basic_auth(options[:user], options[:password])
+
+          response = Net::HTTP.start(uri.host, uri.port, open_timeout: 5, read_timeout: 10) do |http|
+            http.request(req)
+          end
+
+          raise Legion::CLI::Error, "Management API error #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+          ::JSON.parse(response.body, symbolize_names: true)
+        rescue Errno::ECONNREFUSED
+          raise Legion::CLI::Error, "Cannot connect to RabbitMQ management API at #{options[:host]}:#{options[:port]}"
+        rescue Net::OpenTimeout, Net::ReadTimeout
+          raise Legion::CLI::Error, "Timed out connecting to RabbitMQ management API at #{options[:host]}:#{options[:port]}"
+        end
+
+        def management_delete(path)
+          uri = URI("http://#{options[:host]}:#{options[:port]}/api#{path}")
+          req = Net::HTTP::Delete.new(uri)
+          req.basic_auth(options[:user], options[:password])
+
+          Net::HTTP.start(uri.host, uri.port, open_timeout: 5, read_timeout: 10) do |http|
+            http.request(req)
+          end
+        rescue Errno::ECONNREFUSED
+          raise Legion::CLI::Error, "Cannot connect to RabbitMQ management API at #{options[:host]}:#{options[:port]}"
+        end
+
+        def fetch_stats
+          queues    = management_api("/queues/#{vhost_encoded}")
+          exchanges = management_api("/exchanges/#{vhost_encoded}")
+
+          total_consumers = queues.sum { |q| q[:consumers].to_i }
+          dlx_count       = queues.count { |q| q.dig(:arguments, :'x-dead-letter-exchange') }
+
+          {
+            queues:    queues.size,
+            exchanges: exchanges.size,
+            consumers: total_consumers,
+            dlx:       dlx_count
+          }
+        end
+
+        def find_orphans
+          queues = management_api("/queues/#{vhost_encoded}")
+          queues
+            .select { |q| q[:consumers].to_i.zero? && q[:messages].to_i.zero? }
+            .map    { |q| q[:name].to_s }
+        end
+
+        def delete_orphans(orphans)
+          orphans.each do |name|
+            management_delete("/queues/#{vhost_encoded}/#{ERB::Util.url_encode(name)}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/config_command.rb

@@ -192,10 +192,14 @@ module Legion
         out.info("Fetching config from #{source}...")
         body = ConfigImport.fetch_source(source)
         config = ConfigImport.parse_payload(body)
-        path = ConfigImport.write_config(config, force: options[:force])
+        paths = ConfigImport.write_config(config, force: options[:force])
         summary = ConfigImport.summary(config)
 
-        out.success("Config written to #{path}")
+        if paths.empty?
+          out.warn('No config files were written (empty configuration).')
+        else
+          paths.each { |p| out.success("Written: #{p}") }
+        end
         out.info("Sections: #{summary[:sections].join(', ')}")
         if summary[:vault_clusters].any?
           out.info("Vault clusters: #{summary[:vault_clusters].join(', ')}")

data/lib/legion/cli/config_import.rb

@@ -10,7 +10,12 @@ module Legion
   module CLI
     module ConfigImport
       SETTINGS_DIR = File.expand_path('~/.legionio/settings')
-      IMPORT_FILE  = 'imported.json'
+      BOOTSTRAPPED_FILE = 'bootstrapped_settings.json'
+
+      SUBSYSTEM_KEYS = %i[
+        microsoft_teams rbac api logging gaia extensions
+        llm data cache_local cache transport crypt role
+      ].freeze
 
       module_function
 
@@ -56,15 +61,35 @@ module Legion
 
       def write_config(config, force: false)
         FileUtils.mkdir_p(SETTINGS_DIR)
-        path = File.join(SETTINGS_DIR, IMPORT_FILE)
+        written = []
+        remainder = config.dup
+
+        SUBSYSTEM_KEYS.each do |key|
+          next unless remainder.key?(key)
+
+          subsystem_data = remainder.delete(key)
+          path = File.join(SETTINGS_DIR, "#{key}.json")
+          to_write = { key => subsystem_data }
+          if File.exist?(path) && !force
+            existing = ::JSON.parse(File.read(path), symbolize_names: true)
+            existing_subsystem = existing[key]
+            to_write = { key => deep_merge(existing_subsystem, subsystem_data) } if existing_subsystem.is_a?(Hash) && subsystem_data.is_a?(Hash)
+          end
+          File.write(path, "#{::JSON.pretty_generate(to_write)}\n")
+          written << path
+        end
 
-        if File.exist?(path) && !force
-          existing = ::JSON.parse(File.read(path), symbolize_names: true)
-          config = deep_merge(existing, config)
+        unless remainder.empty?
+          path = File.join(SETTINGS_DIR, BOOTSTRAPPED_FILE)
+          if File.exist?(path) && !force
+            existing = ::JSON.parse(File.read(path), symbolize_names: true)
+            remainder = deep_merge(existing, remainder)
+          end
+          File.write(path, "#{::JSON.pretty_generate(remainder)}\n")
+          written << path
         end
 
-        File.write(path, ::JSON.pretty_generate(config))
-        path
+        written
       end
 
       def deep_merge(base, overlay)

data/lib/legion/cli.rb

@@ -66,6 +66,7 @@ module Legion
     autoload :Debug,        'legion/cli/debug_command'
     autoload :CodegenCommand, 'legion/cli/codegen_command'
     autoload :Bootstrap,      'legion/cli/bootstrap_command'
+    autoload :Broker,         'legion/cli/broker_command'
 
     module Groups
       autoload :Ai,       'legion/cli/groups/ai_group'
@@ -275,6 +276,9 @@ module Legion
       desc 'dev SUBCOMMAND', 'Generators, docs, marketplace, and shell completion'
       subcommand 'dev', Legion::CLI::Groups::Dev
 
+      desc 'broker SUBCOMMAND', 'RabbitMQ broker management (stats, cleanup)'
+      subcommand 'broker', Legion::CLI::Broker
+
       desc 'tree', 'Print a tree of all available commands'
       def tree
         legion_print_command_tree(self.class, ::File.basename($PROGRAM_NAME), '')

data/lib/legion/dispatch/local.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module Legion
+  module Dispatch
+    class Local
+      def initialize(pool_size: nil)
+        max = pool_size || Legion::Settings.dig(:dispatch, :local_pool_size) || 8
+        @pool = Concurrent::FixedThreadPool.new(max)
+      end
+
+      def start; end
+
+      def submit(&block)
+        @pool.post do
+          block.call
+        rescue StandardError => e
+          Legion::Logging.error "[Dispatch::Local] #{e.message}" if defined?(Legion::Logging)
+          Legion::Logging.debug e.backtrace&.first(5) if defined?(Legion::Logging)
+        end
+      end
+
+      def stop
+        return unless @pool.running?
+
+        @pool.shutdown
+        @pool.wait_for_termination(15)
+      end
+
+      def capacity
+        {
+          pool_size:    @pool.max_length,
+          queue_length: @pool.queue_length,
+          running:      @pool.running?
+        }
+      end
+    end
+  end
+end

data/lib/legion/dispatch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'dispatch/local'
+
+module Legion
+  module Dispatch
+    class << self
+      def dispatcher
+        @dispatcher ||= Local.new
+      end
+
+      def submit(&)
+        dispatcher.submit(&)
+      end
+
+      def shutdown
+        @dispatcher&.stop
+      end
+
+      def reset!
+        @dispatcher&.stop
+        @dispatcher = nil
+      end
+    end
+  end
+end

data/lib/legion/extensions.rb

@@ -89,6 +89,8 @@ module Legion
 
         @running_instances&.clear
 
+        Legion::Dispatch.shutdown if defined?(Legion::Dispatch) && Legion::Dispatch.instance_variable_get(:@dispatcher)
+
         @loaded_extensions.each do |name|
           Catalog.transition(name, :stopped)
           unregister_capabilities(name)
@@ -283,6 +285,7 @@ module Legion
         end
 
         hook_subscription_actors_pooled(sub_actors) unless sub_actors.empty?
+        dispatch_local_actors(@local_tasks) unless @local_tasks.empty?
 
         @pending_actors.clear
         Legion::Logging.info(
@@ -290,7 +293,8 @@ module Legion
           "every:#{@timer_tasks.count}," \
           "poll:#{@poll_tasks.count}," \
           "once:#{@once_tasks.count}," \
-          "loop:#{@loop_tasks.count}"
+          "loop:#{@loop_tasks.count}," \
+          "local:#{@local_tasks.count}"
         )
         @loaded_extensions&.each { |name| Catalog.transition(name, :running) }
       end
@@ -466,6 +470,32 @@ module Legion
         true
       end
 
+      def dispatch_local_actors(actors)
+        require 'legion/dispatch'
+
+        actors.each do |actor_hash|
+          ext_name = actor_hash[:extension_name]
+
+          runner_mod = actor_hash[:runner_class]
+          unless runner_mod
+            actor_str = actor_hash[:actor_class].to_s
+            runner_str = actor_str.sub('::Actor::', '::Runners::')
+            runner_mod = begin
+              Kernel.const_get(runner_str)
+            rescue NameError
+              Legion::Logging.warn "[LocalDispatch] runner not found for #{ext_name}: #{runner_str}" if defined?(Legion::Logging)
+              next
+            end
+          end
+
+          actor_hash[:runner_module] = runner_mod
+          actor_hash[:running_class] = actor_hash[:actor_class]
+          @running_instances&.push(actor_hash[:actor_class])
+
+          Legion::Logging.info "[LocalDispatch] registered: #{ext_name}/#{actor_hash[:actor_name]}" if defined?(Legion::Logging)
+        end
+      end
+
       public
 
       def unregister_capabilities(gem_name)

data/lib/legion/ingress.rb

@@ -39,7 +39,7 @@ module Legion
 
       # Normalize and execute via Legion::Runner.run.
       # Returns the runner result hash.
-      def run(payload:, runner_class: nil, function: nil, source: 'unknown', principal: nil, **opts) # rubocop:disable Metrics/ParameterLists,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def run(payload:, runner_class: nil, function: nil, source: 'unknown', principal: nil, **opts) # rubocop:disable Metrics/ParameterLists,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
         Legion::Logging.info "[Ingress] run: source=#{source} runner_class=#{runner_class} function=#{function}" if defined?(Legion::Logging)
         check_subtask = opts.fetch(:check_subtask, true)
         generate_task = opts.fetch(:generate_task, true)
@@ -79,6 +79,12 @@ module Legion
 
         Legion::Events.emit('ingress.received', runner_class: rc.to_s, function: fn, source: source)
 
+        if local_runner?(rc)
+          Legion::Logging.debug "[Ingress] local short-circuit: #{rc}.#{fn}" if defined?(Legion::Logging)
+          klass = rc.is_a?(String) ? Kernel.const_get(rc) : rc
+          return klass.send(fn.to_sym, **message)
+        end
+
         runner_block = lambda {
           Legion::Runner.run(
             runner_class:  rc,
@@ -114,6 +120,15 @@ module Legion
         { success: false, status: 'task.blocked', error: { code: 'insufficient_consent', message: e.message } }
       end
 
+      def local_runner?(runner_class)
+        return false unless defined?(Legion::Extensions) && Legion::Extensions.local_tasks.is_a?(Array)
+
+        klass = runner_class.is_a?(String) ? Kernel.const_get(runner_class) : runner_class
+        Legion::Extensions.local_tasks.any? { |t| t[:runner_module] == klass }
+      rescue NameError
+        false
+      end
+
       private
 
       def parse_payload(payload)

data/lib/legion/service.rb

@@ -50,6 +50,8 @@ module Legion
         register_logging_hooks
       end
 
+      setup_dispatch
+
       if cache
         begin
           require 'legion/cache'
@@ -339,6 +341,12 @@ module Legion
       Legion::Logging.warn "Legion::Apollo failed to load: #{e.message}"
     end
 
+    def setup_dispatch
+      require 'legion/dispatch'
+      Legion::Dispatch.dispatcher.start
+      Legion::Logging.info "[Service] Dispatch started (strategy: #{Legion::Dispatch.dispatcher.class.name})"
+    end
+
     def setup_transport
       Legion::Logging.info 'Setting up Legion::Transport'
       require 'legion/transport'
@@ -505,6 +513,8 @@ module Legion
         @cluster_leader = nil
       end
 
+      shutdown_component('Dispatch') { Legion::Dispatch.shutdown } if defined?(Legion::Dispatch)
+
       ext_timeout = Legion::Settings.dig(:extensions, :shutdown_timeout) || 15
       shutdown_component('Extensions', timeout: ext_timeout) { Legion::Extensions.shutdown }
       Legion::Readiness.mark_not_ready(:extensions)

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.9'
+  VERSION = '1.6.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.9
+  version: 1.6.11
 platform: ruby
 authors:
 - Esity
@@ -514,6 +514,7 @@ files:
 - lib/legion/cli/audit_command.rb
 - lib/legion/cli/auth_command.rb
 - lib/legion/cli/bootstrap_command.rb
+- lib/legion/cli/broker_command.rb
 - lib/legion/cli/chain.rb
 - lib/legion/cli/chain_command.rb
 - lib/legion/cli/chat/agent_delegator.rb
@@ -734,6 +735,8 @@ files:
 - lib/legion/digital_worker/registry.rb
 - lib/legion/digital_worker/risk_tier.rb
 - lib/legion/digital_worker/value_metrics.rb
+- lib/legion/dispatch.rb
+- lib/legion/dispatch/local.rb
 - lib/legion/docs/site_generator.rb
 - lib/legion/events.rb
 - lib/legion/extensions.rb