earl-bot 0.1.0

data/lib/earl/mcp/approval_handler.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Earl
+  module Mcp
+    # Handles permission approval flow: posts a permission request to Mattermost,
+    # adds reaction options, and waits for a user reaction to approve or deny.
+    # Tracks per-tool approvals persisted to a global file (allowed_tools.json)
+    # so "always allow" applies across all threads.
+    class ApprovalHandler
+      include Logging
+      include HandlerBase
+
+      TOOL_NAME = "permission_prompt"
+      TOOL_NAMES = [TOOL_NAME].freeze
+
+      INPUT_FORMATTERS = {
+        "Bash" => ->(input) { input["command"].to_s[0..500] },
+        "Edit" => lambda { |input|
+          "#{input["file_path"]}\n#{input.fetch("new_string", input.fetch("content", ""))[0..300]}"
+        },
+        "Write" => lambda { |input|
+          "#{input["file_path"]}\n#{input.fetch("new_string", input.fetch("content", ""))[0..300]}"
+        }
+      }.freeze
+
+      TOOL_SCHEMA = {
+        name: TOOL_NAME,
+        description: "Request permission to execute a tool",
+        inputSchema: {
+          type: "object",
+          properties: {
+            tool_name: { type: "string", description: "Name of the tool requesting permission" },
+            input: { type: "object", description: "The tool's input parameters" }
+          },
+          required: %w[tool_name input]
+        }
+      }.freeze
+
+      def self.allowed_tools_path
+        @allowed_tools_path ||= File.join(Earl.config_root, "allowed_tools.json")
+      end
+
+      # Bundles tool_name and input that travel together through the approval flow.
+      ToolRequest = Data.define(:tool_name, :input)
+
+      # Reaction emoji sets for the permission approval flow.
+      module Reactions
+        APPROVE = %w[+1 white_check_mark].freeze
+        DENY = %w[-1].freeze
+        ALL = %w[+1 white_check_mark -1].freeze
+      end
+
+      def initialize(config:, api_client:)
+        @config = config
+        @api = api_client
+        @allowed_tools = load_allowed_tools
+        @mutex = Mutex.new
+      end
+
+      def tool_definitions
+        [TOOL_SCHEMA]
+      end
+
+      def call(_name, arguments)
+        request = build_request(arguments)
+        format_handler_result(handle(request))
+      end
+
+      def handle(request)
+        return allow_result(request.input) if auto_approved?(request.tool_name)
+
+        post_and_wait(request)
+      end
+
+      private
+
+      def build_request(arguments)
+        ToolRequest.new(
+          tool_name: arguments["tool_name"] || "unknown",
+          input: arguments["input"] || {}
+        )
+      end
+
+      def auto_approved?(tool_name)
+        return false unless @mutex.synchronize { @allowed_tools.include?(tool_name) }
+
+        log(:info, "Auto-allowing #{tool_name} (previously approved)")
+        true
+      end
+
+      def post_and_wait(request)
+        post_id = post_permission_request(request)
+        return deny_result("Failed to post permission request") unless post_id
+
+        add_reaction_options(post_id)
+        decision = wait_for_reaction(post_id, request)
+        delete_permission_post(post_id)
+        decision
+      end
+
+      def allow_result(input)
+        { behavior: "allow", updatedInput: input }
+      end
+
+      def deny_result(reason = "Denied")
+        { behavior: "deny", message: reason }
+      end
+
+      def format_handler_result(result)
+        { content: [{ type: "text", text: JSON.generate(result) }] }
+      end
+
+      # Mattermost posting for permission requests.
+      module PermissionPosting
+        private
+
+        def post_permission_request(request)
+          message = permission_message(request)
+          response = @api.post("/posts", {
+                                 channel_id: @config.platform_channel_id,
+                                 message: message,
+                                 root_id: @config.platform_thread_id
+                               })
+
+          return unless response.is_a?(Net::HTTPSuccess)
+
+          JSON.parse(response.body)["id"]
+        end
+
+        def permission_message(request)
+          tool_name = request.tool_name
+          input_summary = format_input(tool_name, request.input)
+          format_permission_text(tool_name, input_summary)
+        end
+
+        def format_permission_text(tool_name, input_summary)
+          ":lock: **Permission Request**\nClaude wants to run: `#{tool_name}`\n```\n#{input_summary}\n```\n" \
+            "React: :+1: allow once | :white_check_mark: always allow `#{tool_name}` | :-1: deny"
+        end
+
+        def format_input(tool_name, input)
+          formatter = INPUT_FORMATTERS[tool_name]
+          formatter ? formatter.call(input) : JSON.generate(input)[0..500]
+        end
+
+        def add_reaction_options(post_id)
+          Reactions::ALL.each do |emoji|
+            @api.post("/reactions", {
+                        user_id: @config.platform_bot_id,
+                        post_id: post_id,
+                        emoji_name: emoji
+                      })
+          end
+        end
+
+        def delete_permission_post(post_id)
+          @api.delete("/posts/#{post_id}")
+        rescue StandardError => error
+          log(:warn, "Failed to delete permission post #{post_id}: #{error.message}")
+        end
+      end
+
+      # WebSocket-based reaction polling for permission decisions.
+      module ReactionPolling
+        # Bundles poll_for_reaction parameters into a single context object.
+        PollContext = Data.define(:ws, :post_id, :request, :deadline)
+
+        private
+
+        def wait_for_reaction(post_id, request)
+          deadline = Time.now + (@config.permission_timeout_ms / 1000.0)
+          websocket = connect_websocket
+
+          return deny_result("WebSocket connection failed") unless websocket
+
+          context = PollContext.new(ws: websocket, post_id: post_id, request: request, deadline: deadline)
+          poll_for_reaction(context) || deny_result("Timed out waiting for approval")
+        ensure
+          close_websocket(websocket)
+        end
+
+        def close_websocket(websocket)
+          websocket&.close
+        rescue StandardError
+          nil
+        end
+
+        def connect_websocket
+          ws = WebSocket::Client::Simple.connect(@config.websocket_url)
+          token = @config.platform_token
+          ws_ref = ws
+          ws.on(:open) do
+            ws_ref.send(JSON.generate({ seq: 1, action: "authentication_challenge", data: { token: token } }))
+          end
+          ws
+        rescue StandardError => error
+          log(:error, "MCP WebSocket connect failed: #{error.message}")
+          nil
+        end
+
+        def poll_for_reaction(context)
+          reaction_queue = Queue.new
+          register_reaction_listener(context, reaction_queue)
+          poll_reaction_loop(context, reaction_queue)
+        end
+
+        def register_reaction_listener(context, reaction_queue)
+          websocket, target_post_id = context.deconstruct
+          websocket&.on(:message) do |msg|
+            reaction_data = extract_reaction_data(msg.data)
+            reaction_queue.push(reaction_data) if reaction_data && reaction_data["post_id"] == target_post_id
+          end
+        end
+
+        def extract_reaction_data(data)
+          return unless data && !data.empty?
+
+          parsed = JSON.parse(data)
+          event_name, event_data = parsed.values_at("event", "data")
+          return unless event_name == "reaction_added"
+
+          JSON.parse(event_data&.dig("reaction") || "{}")
+        rescue JSON::ParserError
+          log(:debug, "MCP approval: skipped unparsable WebSocket message")
+          nil
+        end
+
+        def poll_reaction_loop(context, reaction_queue)
+          loop do
+            return nil if (context.deadline - Time.now) <= 0
+
+            reaction = dequeue_reaction(reaction_queue)
+            next unless valid_user_reaction?(reaction)
+
+            return process_reaction(reaction["emoji_name"], context.request)
+          end
+        end
+
+        def valid_user_reaction?(reaction)
+          return false unless reaction
+
+          user_id = reaction["user_id"]
+          user_id != @config.platform_bot_id && allowed_reactor?(user_id)
+        end
+
+        def dequeue_reaction(reaction_queue)
+          reaction_queue.pop(true)
+        rescue ThreadError
+          sleep 0.5
+          nil
+        end
+
+        def allowed_reactor?(user_id)
+          allowed = @config.allowed_users
+          return true if allowed.empty?
+
+          response = @api.get("/users/#{user_id}")
+          return false unless response.is_a?(Net::HTTPSuccess)
+
+          user = JSON.parse(response.body)
+          allowed.include?(user["username"])
+        end
+
+        def process_reaction(emoji_name, request)
+          if Reactions::APPROVE.include?(emoji_name)
+            persist_always_allow(request.tool_name) if emoji_name == "white_check_mark"
+            allow_result(request.input)
+          elsif Reactions::DENY.include?(emoji_name)
+            deny_result("Denied by user")
+          end
+        end
+
+        def persist_always_allow(tool_name)
+          @mutex.synchronize { @allowed_tools.add(tool_name) }
+          save_allowed_tools
+        end
+      end
+
+      # Persistence for globally allowed tool list.
+      module AllowedToolsPersistence
+        private
+
+        def load_allowed_tools
+          path = self.class.allowed_tools_path
+          return Set.new unless File.exist?(path)
+
+          Set.new(JSON.parse(File.read(path)))
+        rescue JSON::ParserError, Errno::ENOENT
+          Set.new
+        end
+
+        def save_allowed_tools
+          File.write(self.class.allowed_tools_path, JSON.generate(@allowed_tools.to_a))
+        rescue Errno::ENOENT, Errno::EACCES, Errno::ENOSPC, IOError => error
+          log(:warn, "Failed to save allowed tools: #{error.message}")
+        end
+      end
+
+      include PermissionPosting
+      include ReactionPolling
+      include AllowedToolsPersistence
+    end
+  end
+end

data/lib/earl/mcp/config.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Earl
+  module Mcp
+    # Reads MCP permission server configuration from environment variables,
+    # set by the parent EARL process when spawning Claude with --permission-prompt-tool.
+    class Config
+      attr_reader :allowed_users, :permission_timeout_ms
+
+      # Groups platform connection fields into a single struct.
+      PlatformConnection = Data.define(:url, :token, :channel_id, :thread_id, :bot_id)
+
+      def initialize
+        @platform = PlatformConnection.new(
+          url: required_env("PLATFORM_URL"),
+          token: required_env("PLATFORM_TOKEN"),
+          channel_id: required_env("PLATFORM_CHANNEL_ID"),
+          thread_id: required_env("PLATFORM_THREAD_ID"),
+          bot_id: required_env("PLATFORM_BOT_ID")
+        )
+        @allowed_users = ENV.fetch("ALLOWED_USERS", "").split(",").map(&:strip)
+        @permission_timeout_ms = ENV.fetch("PERMISSION_TIMEOUT_MS", "86400000").to_i
+      end
+
+      def platform_url = @platform.url
+      def platform_token = @platform.token
+      def platform_channel_id = @platform.channel_id
+      def platform_thread_id = @platform.thread_id
+      def platform_bot_id = @platform.bot_id
+
+      def api_url(path)
+        "#{platform_url}/api/v4#{path}"
+      end
+
+      def websocket_url
+        "#{platform_url.sub(%r{^https://}, "wss://").sub(%r{^http://}, "ws://")}/api/v4/websocket"
+      end
+
+      # Build a Config-like object compatible with ApiClient
+      def to_api_config
+        ApiConfig.new(
+          mattermost_url: platform_url,
+          bot_token: platform_token,
+          bot_id: platform_bot_id
+        )
+      end
+
+      # Minimal config struct compatible with ApiClient, built from platform env vars.
+      ApiConfig = Struct.new(:mattermost_url, :bot_token, :bot_id, keyword_init: true) do
+        def api_url(path)
+          "#{mattermost_url}/api/v4#{path}"
+        end
+      end
+
+      private
+
+      def required_env(key)
+        ENV.fetch(key) { raise "Missing required env var: #{key}" }
+      end
+    end
+  end
+end