earl-bot 0.1.0

data/lib/earl/heartbeat_scheduler.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "heartbeat_scheduler/heartbeat_state"
+require_relative "heartbeat_scheduler/execution"
+require_relative "heartbeat_scheduler/lifecycle"
+require_relative "heartbeat_scheduler/config_reloading"
+
+module Earl
+  # Runs heartbeat tasks on cron/interval/one-shot schedules. Spawns Claude sessions
+  # and posts results to Mattermost channels without waiting for user messages.
+  # Auto-reloads config when the YAML file changes. One-off tasks (once: true)
+  # are disabled in YAML after execution.
+  class HeartbeatScheduler
+    include Logging
+    include Execution
+    include Lifecycle
+    include ConfigReloading
+
+    CHECK_INTERVAL = 30 # seconds between scheduler checks
+
+    # Groups injected service dependencies to keep ivar count low.
+    Deps = Struct.new(:config, :mattermost, :heartbeat_config, keyword_init: true)
+
+    # Groups scheduler control state.
+    Control = Struct.new(:scheduler_thread, :stop_requested, :config_mtime, :heartbeat_config_path, keyword_init: true)
+
+    def initialize(config:, mattermost:)
+      heartbeat_config = HeartbeatConfig.new
+      @deps = Deps.new(config: config, mattermost: mattermost, heartbeat_config: heartbeat_config)
+      @control = Control.new(
+        scheduler_thread: nil, stop_requested: false,
+        config_mtime: nil, heartbeat_config_path: heartbeat_config.path
+      )
+      @states = {}
+      @mutex = Mutex.new
+    end
+
+    def start
+      @control.stop_requested = false
+      definitions = @deps.heartbeat_config.definitions
+      initialize_states(definitions) unless definitions.empty?
+      @control.config_mtime = config_file_mtime
+
+      count = definitions.size
+      log(:info, "Heartbeat scheduler starting with #{count} heartbeat(s)")
+
+      @control.scheduler_thread = Thread.new { scheduler_loop }
+    end
+
+    def stop
+      @control.stop_requested = true
+      join_and_kill_thread(@control.scheduler_thread)
+      @control.scheduler_thread = nil
+      stop_heartbeat_threads
+    end
+
+    def status
+      @mutex.synchronize do
+        @states.values.map(&:to_status)
+      end
+    end
+
+    private
+
+    def join_and_kill_thread(thread)
+      return unless thread
+
+      thread.join(5)
+      thread.kill if thread.alive?
+    end
+
+    def stop_heartbeat_threads
+      @mutex.synchronize do
+        @states.each_value do |state|
+          thread = state.run_thread
+          thread&.join(3)
+          thread&.kill if thread&.alive?
+        end
+      end
+    end
+
+    def initialize_states(definitions)
+      now = Time.now
+      @mutex.synchronize do
+        definitions.each do |definition|
+          @states[definition.name] = build_initial_state(definition, now)
+        end
+      end
+    end
+
+    def build_initial_state(definition, now)
+      HeartbeatState.new(
+        definition: definition,
+        next_run_at: compute_next_run(definition, now),
+        running: false,
+        run_count: 0
+      )
+    end
+
+    def scheduler_loop
+      loop do
+        break if @control.stop_requested
+
+        check_for_reload
+        check_and_dispatch
+        sleep CHECK_INTERVAL
+      rescue StandardError => error
+        log(:error, "Heartbeat scheduler error: #{error.message}")
+        log(:error, error.backtrace&.first(5)&.join("\n"))
+      end
+    end
+
+    def check_and_dispatch
+      now = Time.now
+      @mutex.synchronize do
+        @states.each_value do |state|
+          dispatch_heartbeat(state, now) if should_run?(state, now)
+        end
+      end
+    end
+
+    def should_run?(state, now)
+      next_run = state.next_run_at
+      !state.running && next_run && now >= next_run
+    end
+
+    def dispatch_heartbeat(state, now)
+      state.dispatch(now) { execute_heartbeat(state) }
+    end
+  end
+end

data/lib/earl/logging.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Earl
+  # Shared logging convenience for EARL classes, delegating to Earl.logger.
+  module Logging
+    private
+
+    def log(level, message)
+      Earl.logger.public_send(level, message)
+    end
+  end
+end

data/lib/earl/mattermost/api_client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Earl
+  class Mattermost
+    # Handles HTTP requests to the Mattermost REST API, encapsulating
+    # authentication, connection setup, and JSON serialization.
+    class ApiClient
+      include Logging
+
+      # Encapsulates an HTTP request's method, path, and body.
+      Request = Struct.new(:method_class, :path, :body, keyword_init: true)
+
+      def initialize(config)
+        @config = config
+      end
+
+      def get(path)
+        execute(Request.new(method_class: Net::HTTP::Get, path: path, body: nil))
+      end
+
+      def post(path, body)
+        execute(Request.new(method_class: Net::HTTP::Post, path: path, body: body))
+      end
+
+      def put(path, body)
+        execute(Request.new(method_class: Net::HTTP::Put, path: path, body: body))
+      end
+
+      def delete(path)
+        execute(Request.new(method_class: Net::HTTP::Delete, path: path, body: nil))
+      end
+
+      private
+
+      def execute(request)
+        uri = URI.parse(@config.api_url(request.path))
+        http_req = build_request(request.method_class, uri, request.body)
+        response = send_request(uri, http_req)
+        unless response.is_a?(Net::HTTPSuccess)
+          log(:error,
+              "Mattermost API #{http_req.method} #{uri.path} failed: " \
+              "#{response.code} #{response.body[0..200]}")
+        end
+        response
+      end
+
+      def build_request(method_class, uri, body)
+        token = @config.bot_token
+        req = method_class.new(uri)
+        req["Authorization"] = "Bearer #{token}"
+        apply_json_body(req, body) if body
+        req
+      end
+
+      def apply_json_body(req, body)
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      MAX_RETRIES = 2
+      RETRY_DELAY = 1
+      private_constant :MAX_RETRIES, :RETRY_DELAY
+
+      def send_request(uri, req)
+        attempts = 0
+        begin
+          attempts += 1
+          http_start(uri.host, uri.port) { |http| http.request(req) }
+        rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNRESET, Errno::ECONNREFUSED, IOError => error
+          raise if attempts > MAX_RETRIES
+
+          log(:warn, "Mattermost API retry #{attempts}/#{MAX_RETRIES} after #{error.class}: #{error.message}")
+          sleep RETRY_DELAY
+          retry
+        end
+      end
+
+      def http_start(host, port, &)
+        Net::HTTP.start(host, port,
+                        use_ssl: @config.mattermost_url.start_with?("https"),
+                        open_timeout: 10, read_timeout: 15, &)
+      end
+    end
+  end
+end

data/lib/earl/mattermost.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "websocket-client-simple"
+require_relative "mattermost/api_client"
+
+module Earl
+  # Connects to the Mattermost WebSocket API for real-time messaging and
+  # provides REST helpers for creating, updating posts and typing indicators.
+  class Mattermost
+    include Logging
+
+    attr_reader :config
+
+    # Groups WebSocket connection state.
+    Connection = Struct.new(:ws, :channel_ids, keyword_init: true)
+
+    # Groups event callbacks.
+    Callbacks = Struct.new(:on_message, :on_reaction, :on_close, keyword_init: true)
+
+    def initialize(config)
+      @config = config
+      @api = ApiClient.new(config)
+      @connection = Connection.new(ws: nil, channel_ids: Set.new([config.channel_id]))
+      @callbacks = Callbacks.new
+    end
+
+    def configure_channels(channel_ids)
+      @connection.channel_ids = channel_ids
+    end
+
+    def on_message(&block)
+      @callbacks.on_message = block
+    end
+
+    def on_reaction(&block)
+      @callbacks.on_reaction = block
+    end
+
+    def on_close(&block)
+      @callbacks.on_close = block
+    end
+
+    def connect
+      @connection.ws = WebSocket::Client::Simple.connect(config.websocket_url)
+      setup_websocket_handlers
+    end
+
+    def create_post(channel_id:, message:, root_id: nil)
+      body = { channel_id: channel_id, message: message }
+      body[:root_id] = root_id if root_id
+      parse_post_response(@api.post("/posts", body))
+    end
+
+    def update_post(post_id:, message:)
+      @api.put("/posts/#{post_id}", { id: post_id, message: message })
+    end
+
+    def send_typing(channel_id:, parent_id: nil)
+      body = { channel_id: channel_id }
+      body[:parent_id] = parent_id if parent_id
+      @api.post("/users/me/typing", body)
+    end
+
+    def add_reaction(post_id:, emoji_name:)
+      @api.post("/reactions", { user_id: config.bot_id, post_id: post_id, emoji_name: emoji_name })
+    end
+
+    def delete_post(post_id:)
+      @api.delete("/posts/#{post_id}")
+    end
+
+    def get_user(user_id:)
+      parse_post_response(@api.get("/users/#{user_id}"))
+    end
+
+    def get_channel(channel_id:)
+      parse_post_response(@api.get("/channels/#{channel_id}"))
+    end
+
+    # Fetches all posts in a thread, ordered oldest-first.
+    # Returns an array of hashes with :sender, :message, :is_bot.
+    def get_thread_posts(thread_id)
+      response = @api.get("/posts/#{thread_id}/thread")
+      return [] unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      posts, order = data.values_at("posts", "order")
+      build_thread_posts(posts || {}, order || [])
+    rescue JSON::ParserError => error
+      log(:warn, "Failed to parse thread posts: #{error.message}")
+      []
+    end
+
+    private
+
+    def build_thread_posts(posts, order)
+      bot_id = config.bot_id
+      order.reverse.filter_map do |id|
+        format_thread_post(posts[id], bot_id) if posts.key?(id)
+      end
+    end
+
+    def format_thread_post(post, bot_id)
+      from_bot = post.dig("props", "from_bot") == "true"
+      message = post["message"] || ""
+      user_id = post["user_id"]
+      { sender: from_bot ? "EARL" : "user", message: message, is_bot: user_id == bot_id }
+    end
+
+    # WebSocket lifecycle methods extracted to reduce class method count.
+    module WebSocketHandling
+      private
+
+      def setup_websocket_handlers
+        websocket_handler_map.each { |event, handler| @connection.ws.on(event, &handler) }
+      end
+
+      def websocket_handler_map
+        msg_handler = method(:handle_websocket_message)
+        close_handler = method(:handle_websocket_close)
+        auth = method(:auth_payload)
+        {
+          open: -> { send(JSON.generate(auth.call)) },
+          message: ->(msg) { msg_handler.call(msg) },
+          error: ->(error) { Earl.logger.error "WebSocket error: #{error.message}" },
+          close: ->(event) { close_handler.call(event) }
+        }
+      end
+
+      def auth_payload
+        Earl.logger.info "WebSocket connected, sending auth challenge"
+        { seq: 1, action: "authentication_challenge", data: { token: config.bot_token } }
+      end
+
+      def handle_websocket_message(msg)
+        handle_ping if msg.type == :ping
+        parse_and_dispatch(msg.data)
+      rescue StandardError => error
+        log(:error, "WebSocket message error: #{error.class}: #{error.message}")
+        log(:error, error.backtrace&.first(5)&.join("\n"))
+      end
+
+      def parse_and_dispatch(data)
+        return unless data && !data.empty?
+
+        event = parse_ws_json(data)
+        return unless event
+
+        log(:debug, "WS event: #{event["event"] || event.keys.first}")
+        dispatch_event(event)
+      end
+
+      def parse_ws_json(data)
+        JSON.parse(data)
+      rescue JSON::ParserError => error
+        log(:warn, "Failed to parse WebSocket message: #{error.message}")
+        nil
+      end
+
+      def handle_ping
+        log(:debug, "WS ping received, sending pong")
+        @connection.ws.send(nil, type: :pong)
+      end
+
+      def dispatch_event(event)
+        case event["event"]
+        when "hello"
+          log(:info, "Authenticated to Mattermost")
+        when "posted"
+          handle_posted_event(event)
+        when "reaction_added"
+          handle_reaction_event(event)
+        end
+      end
+
+      def handle_websocket_close(event)
+        log(:warn, "WebSocket closed: #{event&.code} #{event&.reason}")
+        log(:warn, "EARL will exit — restart process to reconnect")
+        @callbacks.on_close&.call
+        exit 1
+      end
+    end
+
+    # Event dispatching: routes posted and reaction events to callbacks.
+    module EventDispatching
+      private
+
+      def handle_posted_event(event)
+        post = parse_post_data(event)
+        deliver_message(event, post) if post
+      end
+
+      def handle_reaction_event(event)
+        reaction_data = event.dig("data", "reaction")
+        return unless reaction_data
+
+        reaction = JSON.parse(reaction_data)
+        dispatch_reaction(reaction)
+      rescue JSON::ParserError => error
+        log(:warn, "Failed to parse reaction data: #{error.message}")
+      end
+
+      def dispatch_reaction(reaction)
+        user_id, post_id, emoji_name = reaction.values_at("user_id", "post_id", "emoji_name")
+        return if user_id == config.bot_id
+
+        @callbacks.on_reaction&.call(user_id: user_id, post_id: post_id, emoji_name: emoji_name)
+      end
+
+      def parse_post_data(event)
+        post_data = event.dig("data", "post")
+        return unless post_data
+
+        post = JSON.parse(post_data)
+        return if post["user_id"] == config.bot_id || !@connection.channel_ids.include?(post["channel_id"])
+
+        post
+      end
+
+      def deliver_message(event, post)
+        params = build_message_params(event, post)
+        log(:info,
+            "Message from @#{params[:sender_name]} in thread #{params[:thread_id][0..7]}: #{params[:text][0..80]}")
+        @callbacks.on_message&.call(**params)
+      end
+
+      def build_message_params(event, post)
+        post_id = post["id"]
+        root_id = post["root_id"]
+        sender = event.dig("data", "sender_name")&.delete_prefix("@") || "unknown"
+        {
+          sender_name: sender,
+          thread_id: root_id.to_s.empty? ? post_id : root_id,
+          text: post["message"] || "",
+          post_id: post_id,
+          channel_id: post["channel_id"]
+        }
+      end
+    end
+
+    include WebSocketHandling
+    include EventDispatching
+
+    def parse_post_response(response)
+      return {} unless successful?(response)
+
+      safe_json_parse(response.body)
+    end
+
+    def successful?(response)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    def safe_json_parse(body)
+      JSON.parse(body)
+    rescue JSON::ParserError => error
+      log(:warn, "Failed to parse API response: #{error.message}")
+      {}
+    end
+  end
+end