sidekiq-mcp 0.1.0

data/lib/sidekiq/mcp/sse_middleware.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "rack"
+require "base64"
+require "json"
+require "securerandom"
+
+module Sidekiq
+  module Mcp
+    class SseMiddleware
+      SSE_HEADERS = {
+        'Content-Type' => 'text/event-stream',
+        'Cache-Control' => 'no-cache, no-store, must-revalidate',
+        'Connection' => 'keep-alive',
+        'X-Accel-Buffering' => 'no', # For Nginx
+        'Access-Control-Allow-Origin' => '*',
+        'Access-Control-Allow-Methods' => 'GET, OPTIONS',
+        'Access-Control-Allow-Headers' => 'Content-Type, Authorization',
+        'Access-Control-Max-Age' => '86400',
+        'Keep-Alive' => 'timeout=600',
+        'Pragma' => 'no-cache',
+        'Expires' => '0'
+      }.freeze
+
+      def initialize(app)
+        @app = app
+        @server = Server.new
+        @clients = {}
+        @clients_mutex = Mutex.new
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        
+        return @app.call(env) unless sse_request?(request)
+        return unauthorized_response unless authorized?(request)
+        
+        if request.get?
+          handle_sse_connection(request, env)
+        elsif request.post?
+          handle_mcp_message(request)
+        else
+          method_not_allowed_response
+        end
+      end
+
+      private
+
+      def sse_request?(request)
+        config = Sidekiq::Mcp.configuration || Sidekiq::Mcp::Configuration.new
+        request.path == "#{config.path}/sse"
+      end
+
+      def authorized?(request)
+        config = Sidekiq::Mcp.configuration || Sidekiq::Mcp::Configuration.new
+        
+        return true unless config.auth_token
+        
+        auth_header = request.env["HTTP_AUTHORIZATION"]
+        return false unless auth_header
+        
+        if auth_header.start_with?("Bearer ")
+          token = auth_header.split(" ", 2).last
+          token == config.auth_token
+        elsif auth_header.start_with?("Basic ")
+          encoded = auth_header.split(" ", 2).last
+          decoded = Base64.decode64(encoded)
+          _username, password = decoded.split(":", 2)
+          password == config.auth_token
+        else
+          false
+        end
+      end
+
+      def handle_sse_connection(request, env)
+        client_id = SecureRandom.hex(8)
+        
+        [200, SSE_HEADERS, SseStreamer.new(client_id, self)]
+      end
+
+      def handle_mcp_message(request)
+        body = request.body.read
+        response = @server.handle_request(body)
+        
+        # Broadcast to all SSE clients
+        broadcast_to_clients(response) if response
+        
+        if response.nil?
+          [204, {}, []]
+        else
+          [200, {"Content-Type" => "application/json"}, [response.to_json]]
+        end
+      end
+
+      def broadcast_to_clients(message)
+        @clients_mutex.synchronize do
+          @clients.each_value do |client_data|
+            begin
+              client_data[:stream].write("data: #{message.to_json}\n\n")
+              client_data[:stream].flush
+            rescue
+              # Client disconnected, will be cleaned up later
+            end
+          end
+        end
+      end
+
+      def add_client(client_id, stream)
+        @clients_mutex.synchronize do
+          @clients[client_id] = { stream: stream, connected_at: Time.now }
+        end
+      end
+
+      def remove_client(client_id)
+        @clients_mutex.synchronize do
+          @clients.delete(client_id)
+        end
+      end
+
+      def unauthorized_response
+        [401, { "Content-Type" => "application/json" }, [{ error: "Unauthorized" }.to_json]]
+      end
+
+      def method_not_allowed_response
+        [405, { "Content-Type" => "application/json" }, [{ error: "Method not allowed" }.to_json]]
+      end
+
+      class SseStreamer
+        def initialize(client_id, middleware)
+          @client_id = client_id
+          @middleware = middleware
+        end
+
+        def each
+          @middleware.add_client(@client_id, self)
+          
+          # Send initial connection message
+          yield "data: #{initial_message.to_json}\n\n"
+          
+          # Keep connection alive with heartbeats
+          begin
+            loop do
+              sleep 30
+              yield ": heartbeat\n\n"
+            end
+          rescue
+            # Connection closed
+          ensure
+            @middleware.remove_client(@client_id)
+          end
+        end
+
+        def write(data)
+          @data = data
+        end
+
+        def flush
+          # This method is called by broadcast_to_clients
+          # In a real streaming setup, we'd need to queue messages
+          # For now, this is a simplified implementation
+        end
+
+        private
+
+        def initial_message
+          {
+            jsonrpc: "2.0",
+            method: "connection/established",
+            params: {
+              client_id: @client_id,
+              server_info: {
+                name: "sidekiq-mcp",
+                version: Sidekiq::Mcp::VERSION
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tool.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry-schema"
+
+module Sidekiq
+  module Mcp
+    class Tool
+      class << self
+        attr_accessor :tool_description, :argument_schema
+
+        def description(text)
+          @tool_description = text
+        end
+
+        def arguments(&block)
+          @argument_schema = Dry::Schema.Params(&block) if block_given?
+        end
+
+        def schema_to_json_schema
+          return { type: "object", properties: {}, required: [] } unless @argument_schema
+
+          # For now, return a simple schema - can be enhanced later
+          {
+            type: "object",
+            properties: {},
+            required: []
+          }
+        end
+      end
+
+      def self.to_tool_definition
+        tool_name = name.split("::").last.gsub(/Tool$/, "").gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "")
+        {
+          name: tool_name,
+          description: @tool_description || "#{name} tool",
+          inputSchema: schema_to_json_schema
+        }
+      end
+
+      def call(**args)
+        # Validate arguments if schema is defined
+        if self.class.argument_schema
+          result = self.class.argument_schema.call(args)
+          raise ArgumentError, "Invalid arguments: #{result.errors.to_h}" unless result.success?
+          args = result.to_h
+        end
+
+        perform(**args)
+      end
+
+      def perform(**args)
+        raise NotImplementedError, "Subclasses must implement #perform"
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/clear_queue_tool.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class ClearQueueTool < Tool
+        description "Clear all jobs from a specific queue (destructive operation)"
+
+        arguments do
+          required(:queue_name).filled(:string)
+        end
+
+        def perform(queue_name:)
+          queue = Sidekiq::Queue.new(queue_name)
+          initial_size = queue.size
+          
+          if initial_size == 0
+            "Queue '#{queue_name}' is already empty"
+          else
+            queue.clear
+            "Cleared #{initial_size} jobs from queue '#{queue_name}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/dead_jobs_tool.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class DeadJobsTool < Tool
+        description "Show jobs in the dead set (jobs that have exhausted all retries)"
+
+        arguments do
+          optional(:limit).filled(:integer).value(gteq?: 1, lteq?: 100)
+        end
+
+        def perform(limit: 10)
+          jobs = Sidekiq::DeadSet.new.first(limit).map do |job|
+            {
+              jid: job.jid,
+              class: job.klass,
+              args: job.args,
+              queue: job.queue,
+              error_message: job["error_message"],
+              error_class: job["error_class"],
+              failed_at: job["failed_at"],
+              retry_count: job["retry_count"],
+              died_at: job["died_at"]
+            }
+          end
+          
+          {
+            total_size: Sidekiq::DeadSet.new.size,
+            jobs: jobs
+          }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/failed_jobs_tool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class FailedJobsTool < Tool
+        description "List failed jobs with error details and retry information"
+
+        arguments do
+          optional(:limit).filled(:integer).value(gteq?: 1, lteq?: 100)
+        end
+
+        def perform(limit: 10)
+          failed_set = Sidekiq::RetrySet.new
+          jobs = failed_set.first(limit).map do |job|
+            {
+              jid: job.jid,
+              class: job.klass,
+              args: job.args,
+              queue: job.queue,
+              error_message: job["error_message"],
+              error_class: job["error_class"],
+              failed_at: job["failed_at"],
+              retry_count: job["retry_count"],
+              retried_at: job["retried_at"]
+            }
+          end
+          
+          {
+            total_size: failed_set.size,
+            jobs: jobs
+          }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/job_class_stats_tool.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class JobClassStatsTool < Tool
+        description "Breakdown of job counts, retries, and error rates by class"
+
+        arguments do
+          # No arguments needed
+        end
+
+        def perform
+          stats = {}
+          
+          # Get stats from retry set
+          Sidekiq::RetrySet.new.each do |job|
+            klass = job.klass
+            stats[klass] ||= { retry_count: 0, failed_count: 0, total_retries: 0 }
+            stats[klass][:retry_count] += 1
+            stats[klass][:total_retries] += (job["retry_count"] || 0)
+          end
+          
+          # Get stats from dead set
+          Sidekiq::DeadSet.new.each do |job|
+            klass = job.klass
+            stats[klass] ||= { retry_count: 0, failed_count: 0, total_retries: 0 }
+            stats[klass][:failed_count] += 1
+          end
+          
+          # Get stats from queues
+          Sidekiq::Queue.all.each do |queue|
+            queue.each do |job|
+              klass = job.klass
+              stats[klass] ||= { retry_count: 0, failed_count: 0, total_retries: 0, enqueued_count: 0 }
+              stats[klass][:enqueued_count] = (stats[klass][:enqueued_count] || 0) + 1
+            end
+          end
+          
+          # Calculate error rates
+          stats.each do |klass, data|
+            total_jobs = (data[:retry_count] || 0) + (data[:failed_count] || 0) + (data[:enqueued_count] || 0)
+            error_count = (data[:retry_count] || 0) + (data[:failed_count] || 0)
+            data[:error_rate] = total_jobs > 0 ? (error_count.to_f / total_jobs * 100).round(2) : 0
+            data[:total_jobs] = total_jobs
+          end
+          
+          stats.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/job_details_tool.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class JobDetailsTool < Tool
+        description "Show args, error message, and history for a job by JID (failed, scheduled, or retry)"
+
+        arguments do
+          required(:jid).filled(:string)
+        end
+
+        def perform(jid:)
+          job = find_job_by_jid(jid)
+          
+          return "Job #{jid} not found" unless job
+          
+          details = {
+            jid: job.jid,
+            class: job.klass,
+            args: job.args,
+            queue: job.queue,
+            created_at: job.created_at,
+            enqueued_at: job.enqueued_at
+          }
+          
+          # Add retry/failure specific info
+          if job.respond_to?(:[])
+            details[:error_message] = job["error_message"] if job["error_message"]
+            details[:error_class] = job["error_class"] if job["error_class"]
+            details[:failed_at] = job["failed_at"] if job["failed_at"]
+            details[:retry_count] = job["retry_count"] if job["retry_count"]
+            details[:retried_at] = job["retried_at"] if job["retried_at"]
+            details[:backtrace] = job["error_backtrace"] if job["error_backtrace"]
+          end
+          
+          # Add scheduled info
+          if job.respond_to?(:at)
+            details[:scheduled_at] = job.at
+          end
+          
+          details.to_json
+        end
+
+        private
+
+        def find_job_by_jid(jid)
+          # Check retry set
+          job = Sidekiq::RetrySet.new.find_job(jid)
+          return job if job
+          
+          # Check scheduled set
+          job = Sidekiq::ScheduledSet.new.find_job(jid)
+          return job if job
+          
+          # Check dead set
+          job = Sidekiq::DeadSet.new.find_job(jid)
+          return job if job
+          
+          # Check all queues
+          Sidekiq::Queue.all.each do |queue|
+            job = queue.find_job(jid)
+            return job if job
+          end
+          
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/kill_job_tool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class KillJobTool < Tool
+        description "Move a job from retry/scheduled set to the dead set"
+
+        arguments do
+          required(:jid).filled(:string)
+        end
+
+        def perform(jid:)
+          # Try retry set first
+          retry_set = Sidekiq::RetrySet.new
+          job = retry_set.find_job(jid)
+          
+          if job
+            job.kill
+            return "Job #{jid} moved from retry set to dead set"
+          end
+          
+          # Try scheduled set
+          scheduled_set = Sidekiq::ScheduledSet.new
+          job = scheduled_set.find_job(jid)
+          
+          if job
+            job.kill
+            return "Job #{jid} moved from scheduled set to dead set"
+          end
+          
+          "Job #{jid} not found in retry or scheduled sets"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/list_retry_jobs_tool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class ListRetryJobsTool < Tool
+        description "List jobs in the retry set (jobs that failed but will be retried)"
+
+        arguments do
+          optional(:limit).filled(:integer).value(gteq?: 1, lteq?: 100)
+        end
+
+        def perform(limit: 10)
+          jobs = Sidekiq::RetrySet.new.first(limit).map do |job|
+            {
+              jid: job.jid,
+              class: job.klass,
+              args: job.args,
+              queue: job.queue,
+              error_message: job["error_message"],
+              error_class: job["error_class"],
+              failed_at: job["failed_at"],
+              retry_count: job["retry_count"],
+              retried_at: job["retried_at"],
+              next_retry_at: job.at
+            }
+          end
+          
+          {
+            total_size: Sidekiq::RetrySet.new.size,
+            jobs: jobs
+          }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/list_scheduled_jobs_tool.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class ListScheduledJobsTool < Tool
+        description "List jobs in the scheduled set"
+
+        arguments do
+          optional(:limit).filled(:integer).value(gteq?: 1, lteq?: 100)
+        end
+
+        def perform(limit: 10)
+          jobs = Sidekiq::ScheduledSet.new.first(limit).map do |job|
+            {
+              jid: job.jid,
+              class: job.klass,
+              args: job.args,
+              queue: job.queue,
+              scheduled_at: job.at,
+              created_at: job.created_at
+            }
+          end
+          
+          {
+            total_size: Sidekiq::ScheduledSet.new.size,
+            jobs: jobs
+          }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/process_set_tool.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class ProcessSetTool < Tool
+        description "Get detailed information about all Sidekiq processes/workers"
+
+        arguments do
+          # No arguments needed
+        end
+
+        def perform
+          processes = Sidekiq::ProcessSet.new.map do |process|
+            {
+              identity: process["identity"],
+              hostname: process["hostname"],
+              pid: process["pid"],
+              tag: process["tag"],
+              concurrency: process["concurrency"],
+              queues: process["queues"],
+              busy: process["busy"],
+              beat: process["beat"],
+              quiet: process["quiet"],
+              started_at: process["started_at"],
+              labels: process["labels"],
+              version: process["version"],
+              rss_kb: process["rss"]
+            }
+          end
+          
+          {
+            total_processes: processes.size,
+            processes: processes
+          }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/mcp/tools/queue_details_tool.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../tool"
+require "sidekiq/api"
+
+module Sidekiq
+  module Mcp
+    module Tools
+      class QueueDetailsTool < Tool
+        description "Get detailed information about a specific queue including jobs"
+
+        arguments do
+          required(:queue_name).filled(:string)
+          optional(:limit).filled(:integer).value(gteq?: 1, lteq?: 100)
+        end
+
+        def perform(queue_name:, limit: 10)
+          queue = Sidekiq::Queue.new(queue_name)
+          jobs = queue.first(limit).map do |job|
+            {
+              jid: job.jid,
+              class: job.klass,
+              args: job.args,
+              created_at: job.created_at,
+              enqueued_at: job.enqueued_at,
+              queue: job.queue
+            }
+          end
+          
+          {
+            queue_name: queue_name,
+            size: queue.size,
+            latency: queue.latency,
+            jobs: jobs
+          }.to_json
+        end
+      end
+    end
+  end
+end