claude_swarm 0.1.14 → 0.1.16

data/lib/claude_swarm/permission_mcp_server.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fast_mcp"
-require "logger"
-require "fileutils"
-require_relative "permission_tool"
-require_relative "session_path"
-require_relative "process_tracker"
-
-module ClaudeSwarm
-  class PermissionMcpServer
-    # Server configuration
-    SERVER_NAME = "claude-swarm-permissions"
-    SERVER_VERSION = "1.0.0"
-
-    # Tool categories
-    FILE_TOOLS = %w[Read Write Edit].freeze
-    BASH_TOOL = "Bash"
-
-    # Pattern matching
-    TOOL_PATTERN_REGEX = /^([^()]+)\(([^)]+)\)$/
-    PARAM_PATTERN_REGEX = /^(\w+)\s*:\s*(.+)$/
-
-    def initialize(allowed_tools: nil, disallowed_tools: nil)
-      @allowed_tools = allowed_tools
-      @disallowed_tools = disallowed_tools
-      setup_logging
-    end
-
-    def start
-      configure_permission_tool
-      create_and_start_server
-    end
-
-    private
-
-    def configure_permission_tool
-      allowed_patterns = parse_tool_patterns(@allowed_tools)
-      disallowed_patterns = parse_tool_patterns(@disallowed_tools)
-
-      log_configuration(allowed_patterns, disallowed_patterns)
-
-      PermissionTool.allowed_patterns = allowed_patterns
-      PermissionTool.disallowed_patterns = disallowed_patterns
-      PermissionTool.logger = @logger
-    end
-
-    def create_and_start_server
-      # Track this process
-      session_path = SessionPath.from_env
-      if session_path && File.exist?(session_path)
-        tracker = ProcessTracker.new(session_path)
-        tracker.track_pid(Process.pid, "mcp_permissions")
-      end
-
-      server = FastMcp::Server.new(
-        name: SERVER_NAME,
-        version: SERVER_VERSION
-      )
-
-      server.register_tool(PermissionTool)
-      @logger.info("Permission MCP server started successfully")
-      server.start
-    end
-
-    def setup_logging
-      session_path = SessionPath.from_env
-      SessionPath.ensure_directory(session_path)
-      @logger = create_logger(session_path)
-      @logger.info("Permission MCP server logging initialized")
-    end
-
-    def create_logger(session_path)
-      log_path = File.join(session_path, "permissions.log")
-      logger = Logger.new(log_path)
-      logger.level = Logger::DEBUG
-      logger.formatter = log_formatter
-      logger
-    end
-
-    def log_formatter
-      proc do |severity, datetime, _progname, msg|
-        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S.%L")}] [#{severity}] #{msg}\n"
-      end
-    end
-
-    def log_configuration(allowed_patterns, disallowed_patterns)
-      @logger.info("Starting permission MCP server with allowed patterns: #{allowed_patterns.inspect}, " \
-                   "disallowed patterns: #{disallowed_patterns.inspect}")
-    end
-
-    def parse_tool_patterns(tools)
-      return [] if tools.nil? || tools.empty?
-
-      normalize_tool_list(tools).filter_map do |tool|
-        parse_single_tool_pattern(tool.strip)
-      end
-    end
-
-    def normalize_tool_list(tools)
-      tools.is_a?(Array) ? tools : tools.split(/[,\s]+/)
-    end
-
-    def parse_single_tool_pattern(tool)
-      return nil if tool.empty?
-
-      if (match = tool.match(TOOL_PATTERN_REGEX))
-        parse_tool_with_pattern(match[1], match[2])
-      elsif tool.include?("*")
-        create_wildcard_tool_pattern(tool)
-      else
-        create_exact_tool_pattern(tool)
-      end
-    end
-
-    def parse_tool_with_pattern(tool_name, pattern)
-      case tool_name
-      when *FILE_TOOLS
-        create_file_tool_pattern(tool_name, pattern)
-      when BASH_TOOL
-        create_bash_tool_pattern(tool_name, pattern)
-      else
-        create_custom_tool_pattern(tool_name, pattern)
-      end
-    end
-
-    def create_file_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: File.expand_path(pattern),
-        type: :glob
-      }
-    end
-
-    def create_bash_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: process_bash_pattern(pattern),
-        type: :regex
-      }
-    end
-
-    def process_bash_pattern(pattern)
-      if pattern.include?(":")
-        # Colon syntax: convert parts and join with spaces
-        pattern.split(":")
-               .map { |part| part.gsub("*", ".*") }
-               .join(" ")
-      else
-        # Literal pattern: escape asterisks
-        pattern.gsub("*", "\\*")
-      end
-    end
-
-    def create_custom_tool_pattern(tool_name, pattern)
-      {
-        tool_name: tool_name,
-        pattern: parse_parameter_patterns(pattern),
-        type: :params
-      }
-    end
-
-    def parse_parameter_patterns(pattern)
-      pattern.split(",").each_with_object({}) do |param_pair, params|
-        param_pair = param_pair.strip
-        if (match = param_pair.match(PARAM_PATTERN_REGEX))
-          params[match[1]] = match[2]
-        end
-      end
-    end
-
-    def create_wildcard_tool_pattern(tool)
-      {
-        tool_name: tool.gsub("*", ".*"),
-        pattern: nil,
-        type: :regex
-      }
-    end
-
-    def create_exact_tool_pattern(tool)
-      {
-        tool_name: tool,
-        pattern: nil,
-        type: :exact
-      }
-    end
-  end
-end

data/lib/claude_swarm/permission_tool.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fast_mcp"
-
-module ClaudeSwarm
-  class PermissionTool < FastMcp::Tool
-    # Class variables to store allowed/disallowed patterns and logger
-    class << self
-      attr_accessor :allowed_patterns, :disallowed_patterns, :logger
-    end
-
-    # Tool categories
-    FILE_TOOLS = %w[Read Write Edit].freeze
-    BASH_TOOL = "Bash"
-
-    # Response behaviors
-    BEHAVIOR_ALLOW = "allow"
-    BEHAVIOR_DENY = "deny"
-
-    # File matching flags
-    FILE_MATCH_FLAGS = File::FNM_DOTMATCH | File::FNM_PATHNAME | File::FNM_EXTGLOB
-
-    tool_name "check_permission"
-    description "Check if a tool is allowed to be used based on configured patterns"
-
-    arguments do
-      required(:tool_name).filled(:string).description("The tool requesting permission")
-      required(:input).value(:hash).description("The input for the tool")
-    end
-
-    def call(tool_name:, input:)
-      @current_tool_name = tool_name
-      log_request(tool_name, input)
-
-      result = evaluate_permission(tool_name, input)
-      response = JSON.generate(result)
-
-      log_response(response)
-      response
-    end
-
-    private
-
-    def evaluate_permission(tool_name, input)
-      if explicitly_disallowed?(tool_name, input)
-        deny_response(tool_name, "explicitly disallowed")
-      elsif implicitly_allowed?(tool_name, input)
-        allow_response(input)
-      else
-        deny_response(tool_name, "not allowed by configured patterns")
-      end
-    end
-
-    def explicitly_disallowed?(tool_name, input)
-      check_patterns(disallowed_patterns, tool_name, input, "Disallowed")
-    end
-
-    def implicitly_allowed?(tool_name, input)
-      allowed_patterns.empty? || check_patterns(allowed_patterns, tool_name, input, "Allowed")
-    end
-
-    def check_patterns(patterns, tool_name, input, pattern_type)
-      patterns.any? do |pattern_hash|
-        match = matches_pattern?(tool_name, input, pattern_hash)
-        log_pattern_check(pattern_type, pattern_hash, tool_name, input, match)
-        match
-      end
-    end
-
-    def matches_pattern?(tool_name, input, pattern_hash)
-      return false unless tool_name_matches?(tool_name, pattern_hash)
-      return true if pattern_hash[:pattern].nil?
-
-      match_tool_specific_pattern(tool_name, input, pattern_hash)
-    end
-
-    def tool_name_matches?(tool_name, pattern_hash)
-      case pattern_hash[:type]
-      when :regex
-        tool_name.match?(/^#{pattern_hash[:tool_name]}$/)
-      else
-        tool_name == pattern_hash[:tool_name]
-      end
-    end
-
-    def match_tool_specific_pattern(_tool_name, input, pattern_hash)
-      case pattern_hash[:tool_name]
-      when BASH_TOOL
-        match_bash_pattern(input, pattern_hash)
-      when *FILE_TOOLS
-        match_file_pattern(input, pattern_hash[:pattern])
-      else
-        match_custom_tool_pattern(input, pattern_hash)
-      end
-    end
-
-    def match_bash_pattern(input, pattern_hash)
-      command = extract_field_value(input, "command")
-      return false unless command
-
-      if pattern_hash[:type] == :regex
-        command.match?(/^#{pattern_hash[:pattern]}$/)
-      else
-        command == pattern_hash[:pattern]
-      end
-    end
-
-    def match_file_pattern(input, pattern)
-      file_path = extract_field_value(input, "file_path")
-      unless file_path
-        log_missing_field("file_path", input)
-        return false
-      end
-
-      File.fnmatch(pattern, File.expand_path(file_path), FILE_MATCH_FLAGS)
-    end
-
-    def match_custom_tool_pattern(input, pattern_hash)
-      return false unless pattern_hash[:type] == :params && pattern_hash[:pattern].is_a?(Hash)
-      return false if pattern_hash[:pattern].empty?
-
-      match_parameter_patterns(input, pattern_hash[:pattern])
-    end
-
-    def match_parameter_patterns(input, param_patterns)
-      param_patterns.all? do |param_name, param_pattern|
-        value = extract_field_value(input, param_name.to_s)
-        return false unless value
-
-        regex_pattern = glob_to_regex(param_pattern)
-        value.to_s.match?(/^#{regex_pattern}$/)
-      end
-    end
-
-    def extract_field_value(input, field_name)
-      input[field_name] || input[field_name.to_sym]
-    end
-
-    def glob_to_regex(pattern)
-      Regexp.escape(pattern)
-            .gsub('\*', ".*")
-            .gsub('\?', ".")
-    end
-
-    # Response builders
-    def allow_response(input)
-      log_decision("ALLOWED", "matches configured patterns")
-      {
-        "behavior" => BEHAVIOR_ALLOW,
-        "updatedInput" => input
-      }
-    end
-
-    def deny_response(tool_name, reason)
-      log_decision("DENIED", "is #{reason}")
-      {
-        "behavior" => BEHAVIOR_DENY,
-        "message" => "Tool '#{tool_name}' is #{reason}"
-      }
-    end
-
-    # Logging helpers
-    def log_request(tool_name, input)
-      logger&.info("Permission check requested for tool: #{tool_name}")
-      logger&.info("Tool input: #{input.inspect}")
-      logger&.info("Checking against allowed patterns: #{allowed_patterns.inspect}")
-      logger&.info("Checking against disallowed patterns: #{disallowed_patterns.inspect}")
-    end
-
-    def log_response(response)
-      logger&.info("Returning response: #{response}")
-    end
-
-    def log_pattern_check(pattern_type, pattern_hash, tool_name, input, match)
-      logger&.info("#{pattern_type} pattern '#{pattern_hash.inspect}' vs '#{tool_name}' " \
-                   "with input '#{input.inspect}': #{match}")
-    end
-
-    def log_decision(status, reason)
-      logger&.info("#{status}: Tool '#{@current_tool_name}' #{reason}")
-    end
-
-    def log_missing_field(field_name, input)
-      logger&.info("#{field_name} not found in input: #{input.inspect}")
-    end
-
-    # Convenience accessors
-    def logger
-      self.class.logger
-    end
-
-    def allowed_patterns
-      self.class.allowed_patterns || []
-    end
-
-    def disallowed_patterns
-      self.class.disallowed_patterns || []
-    end
-  end
-end