legion-mcp 0.1.0

data/lib/legion/mcp/tools/list_schedules.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListSchedules < ::MCP::Tool
+        tool_name 'legion.list_schedules'
+        description 'List all schedules. Requires lex-scheduler.'
+
+        input_schema(
+          properties: {
+            active: { type: 'boolean', description: 'Filter by active status' },
+            limit:  { type: 'integer', description: 'Max results (default 25, max 100)' }
+          }
+        )
+
+        class << self
+          def call(active: nil, limit: 25)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('lex-scheduler is not loaded') unless scheduler_loaded?
+
+            limit = limit.to_i.clamp(1, 100)
+            dataset = Legion::Extensions::Scheduler::Data::Model::Schedule.order(:id)
+            dataset = dataset.where(active: true) if active == true
+            text_response(dataset.limit(limit).all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list schedules: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def scheduler_loaded? = defined?(Legion::Extensions::Scheduler)
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/list_tasks.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListTasks < ::MCP::Tool
+        tool_name 'legion.list_tasks'
+        description 'List recent tasks with optional filtering by status or function_id.'
+
+        input_schema(
+          properties: {
+            status:      { type: 'string', description: 'Filter by task status' },
+            function_id: { type: 'integer', description: 'Filter by function ID' },
+            limit:       { type: 'integer', description: 'Max results (default 25, max 100)' }
+          }
+        )
+
+        class << self
+          def call(status: nil, function_id: nil, limit: 25)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            limit = limit.to_i.clamp(1, 100)
+            dataset = Legion::Data::Model::Task.order(Sequel.desc(:id))
+            dataset = dataset.where(status: status) if status
+            dataset = dataset.where(function_id: function_id.to_i) if function_id
+            text_response(dataset.limit(limit).all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list tasks: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/list_workers.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListWorkers < ::MCP::Tool
+        tool_name 'legion.list_workers'
+        description 'List digital workers with optional filtering by team, owner, or lifecycle state.'
+
+        input_schema(
+          properties: {
+            team:            { type: 'string',  description: 'Filter by team name' },
+            owner_msid:      { type: 'string',  description: 'Filter by owner MSID' },
+            lifecycle_state: { type:        'string',
+                               description: 'Filter by lifecycle state (bootstrap, active, paused, retired, terminated)' },
+            limit:           { type: 'integer', description: 'Max results (default 20, max 100)' }
+          }
+        )
+
+        class << self
+          def call(team: nil, owner_msid: nil, lifecycle_state: nil, limit: 20)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            limit   = limit.to_i.clamp(1, 100)
+            dataset = Legion::Data::Model::DigitalWorker.order(Sequel.desc(:id))
+            dataset = dataset.where(team: team)                       if team
+            dataset = dataset.where(owner_msid: owner_msid)           if owner_msid
+            dataset = dataset.where(lifecycle_state: lifecycle_state) if lifecycle_state
+
+            text_response(dataset.limit(limit).all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list workers: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/rbac_assignments.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class RbacAssignments < ::MCP::Tool
+        tool_name 'legion.rbac_assignments'
+        description 'List RBAC role assignments. Filterable by team, role, or principal.'
+
+        input_schema(
+          properties: {
+            team:      { type: 'string', description: 'Filter by team' },
+            role:      { type: 'string', description: 'Filter by role name' },
+            principal: { type: 'string', description: 'Filter by principal ID' }
+          }
+        )
+
+        class << self
+          def call(team: nil, role: nil, principal: nil)
+            return error_response('legion-rbac not installed') unless defined?(Legion::Rbac)
+            return error_response('legion-data not connected') unless Legion::Rbac::Store.db_available?
+
+            ds = Legion::Data::Model::RbacRoleAssignment.dataset
+            ds = ds.where(team: team) if team
+            ds = ds.where(role: role) if role
+            ds = ds.where(principal_id: principal) if principal
+            text_response(ds.all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list assignments: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/rbac_check.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class RbacCheck < ::MCP::Tool
+        tool_name 'legion.rbac_check'
+        description 'Dry-run authorization check. Evaluates RBAC policies without enforcing.'
+
+        input_schema(
+          properties: {
+            principal: { type: 'string', description: 'Principal ID to check' },
+            action:    { type: 'string', description: 'Action (read, execute, manage, etc.)' },
+            resource:  { type: 'string', description: 'Resource path (e.g. runners/lex-github/*)' },
+            roles:     { type: 'array', items: { type: 'string' }, description: 'Roles to evaluate' },
+            team:      { type: 'string', description: 'Team scope' }
+          },
+          required:   %w[principal action resource roles]
+        )
+
+        class << self
+          def call(principal:, action:, resource:, roles: [], team: nil)
+            return error_response('legion-rbac not installed') unless defined?(Legion::Rbac)
+
+            p = Legion::Rbac::Principal.new(id: principal, roles: roles, team: team)
+            result = Legion::Rbac::PolicyEngine.evaluate(principal: p, action: action, resource: resource,
+                                                         enforce: false)
+            text_response(result)
+          rescue StandardError => e
+            error_response("RBAC check failed: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/rbac_grants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class RbacGrants < ::MCP::Tool
+        tool_name 'legion.rbac_grants'
+        description 'List RBAC runner grants. Filterable by team.'
+
+        input_schema(
+          properties: {
+            team: { type: 'string', description: 'Filter by team' }
+          }
+        )
+
+        class << self
+          def call(team: nil)
+            return error_response('legion-rbac not installed') unless defined?(Legion::Rbac)
+            return error_response('legion-data not connected') unless Legion::Rbac::Store.db_available?
+
+            ds = Legion::Data::Model::RbacRunnerGrant.dataset
+            ds = ds.where(team: team) if team
+            text_response(ds.all.map(&:values))
+          rescue StandardError => e
+            error_response("Failed to list grants: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/routing_stats.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class RoutingStats < ::MCP::Tool
+        tool_name 'legion.routing_stats'
+        description 'Retrieve LLM routing statistics: breakdown by provider, model, and routing reason. Requires lex-metering.'
+
+        input_schema(
+          properties: {
+            worker_id: { type: 'string', description: 'Optional: filter stats to a specific worker UUID' }
+          }
+        )
+
+        class << self
+          def call(worker_id: nil)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('lex-metering is not loaded') unless metering_available?
+
+            runner = Object.new.extend(Legion::Extensions::Metering::Runners::Metering)
+            stats = runner.routing_stats(worker_id: worker_id)
+            text_response(stats)
+          rescue StandardError => e
+            error_response("Failed to fetch routing stats: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def metering_available?
+            defined?(Legion::Extensions::Metering::Runners::Metering)
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/run_task.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class RunTask < ::MCP::Tool
+        tool_name 'legion.run_task'
+        description 'Execute a Legion task using dot notation (e.g., "http.request.get"). Returns the task result.'
+
+        input_schema(
+          properties: {
+            task:   {
+              type:        'string',
+              description: 'Dot notation path: extension.runner.function (e.g., "http.request.get")'
+            },
+            params: {
+              type:                 'object',
+              description:          'Parameters to pass to the task function',
+              additionalProperties: true
+            }
+          },
+          required:   ['task']
+        )
+
+        class << self
+          def call(task:, params: {})
+            parts = task.split('.')
+            return error_response("Invalid dot notation '#{task}'. Expected format: extension.runner.function") unless parts.length == 3
+
+            ext_name, runner_name, function_name = parts
+            runner_class = resolve_runner_class(ext_name, runner_name)
+
+            result = Legion::Ingress.run(
+              payload:       params,
+              runner_class:  runner_class,
+              function:      function_name.to_sym,
+              source:        'mcp',
+              check_subtask: true,
+              generate_task: true
+            )
+
+            text_response(result)
+          rescue NameError => e
+            error_response("Runner not found: #{e.message}")
+          rescue StandardError => e
+            error_response("Task execution failed: #{e.message}")
+          end
+
+          private
+
+          def resolve_runner_class(ext_name, runner_name)
+            ext_part = ext_name.split('_').map(&:capitalize).join
+            runner_part = runner_name.split('_').map(&:capitalize).join
+            "Legion::Extensions::#{ext_part}::Runners::#{runner_part}"
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(message)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: message }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/show_worker.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ShowWorker < ::MCP::Tool
+        tool_name 'legion.show_worker'
+        description 'Get full details for a single digital worker by ID.'
+
+        input_schema(
+          properties: {
+            worker_id: { type: 'string', description: 'UUID of the digital worker' }
+          },
+          required:   ['worker_id']
+        )
+
+        class << self
+          def call(worker_id:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            worker = Legion::DigitalWorker.find(worker_id: worker_id)
+            return error_response("Worker not found: #{worker_id}") unless worker
+
+            text_response(worker.values)
+          rescue StandardError => e
+            error_response("Failed to fetch worker: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/team_summary.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class TeamSummary < ::MCP::Tool
+        tool_name 'legion.team_summary'
+        description 'Get a summary of all digital workers for a team, including lifecycle state breakdown.'
+
+        input_schema(
+          properties: {
+            team: { type: 'string', description: 'Team name to summarize' }
+          },
+          required:   ['team']
+        )
+
+        class << self
+          def call(team:)
+            return error_response('legion-data is not connected') unless data_connected?
+
+            workers = Legion::DigitalWorker.by_team(team: team).all
+            breakdown = workers.each_with_object(Hash.new(0)) { |w, counts| counts[w.values[:lifecycle_state]] += 1 }
+
+            text_response({
+                            team:             team,
+                            total:            workers.size,
+                            lifecycle_states: breakdown,
+                            workers:          workers.map do |w|
+                              w.values.slice(:worker_id, :name, :lifecycle_state, :owner_msid, :business_role)
+                            end
+                          })
+          rescue StandardError => e
+            error_response("Failed to fetch team summary: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/update_chain.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class UpdateChain < ::MCP::Tool
+        tool_name 'legion.update_chain'
+        description 'Update an existing task chain.'
+
+        input_schema(
+          properties: {
+            id:   { type: 'integer', description: 'Chain ID' },
+            name: { type: 'string', description: 'New chain name' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:, **attrs)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('chain data model is not available') unless chain_model?
+
+            record = Legion::Data::Model::Chain[id.to_i]
+            return error_response("Chain #{id} not found") unless record
+
+            record.update(attrs) unless attrs.empty?
+            record.refresh
+            text_response(record.values)
+          rescue StandardError => e
+            error_response("Failed to update chain: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def chain_model? = Legion::Data::Model.const_defined?(:Chain)
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/update_relationship.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class UpdateRelationship < ::MCP::Tool
+        tool_name 'legion.update_relationship'
+        description 'Update an existing relationship.'
+
+        input_schema(
+          properties: {
+            id:                  { type: 'integer', description: 'Relationship ID' },
+            trigger_function_id: { type: 'integer', description: 'New trigger function ID' },
+            target_function_id:  { type: 'integer', description: 'New target function ID' }
+          },
+          required:   ['id']
+        )
+
+        class << self
+          def call(id:, **attrs)
+            return error_response('legion-data is not connected') unless data_connected?
+            return error_response('relationship data model is not available') unless relationship_model?
+
+            record = Legion::Data::Model::Relationship[id.to_i]
+            return error_response("Relationship #{id} not found") unless record
+
+            record.update(attrs) unless attrs.empty?
+            record.refresh
+            text_response(record.values)
+          rescue StandardError => e
+            error_response("Failed to update relationship: #{e.message}")
+          end
+
+          private
+
+          def data_connected?
+            Legion::Settings[:data][:connected]
+          rescue StandardError
+            false
+          end
+
+          def relationship_model? = Legion::Data::Model.const_defined?(:Relationship)
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end