brainiac-discord 0.0.1

data/lib/brainiac/plugins/discord/config.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord configuration — loads ~/.brainiac/discord.json.
+      # Provides channel mappings, authorization, user mappings, and project routing.
+      module Config
+        DISCORD_CONFIG_FILE = File.join(
+          ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")),
+          "discord.json"
+        )
+
+        DISCORD_THREAD_MAP_FILE = File.join(
+          ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")),
+          "discord_thread_map.json"
+        )
+
+        @config = {}
+        @thread_map_mutex = Mutex.new
+
+        class << self
+          attr_reader :config, :thread_map_mutex
+
+          def load!
+            @config = if File.exist?(DISCORD_CONFIG_FILE)
+                        JSON.parse(File.read(DISCORD_CONFIG_FILE))
+                      else
+                        { "channel_mappings" => {}, "authorized_role_ids" => [], "authorized_user_ids" => [] }
+                      end
+          rescue JSON::ParserError => e
+            LOG.error "[Discord] Failed to parse discord.json: #{e.message}" if defined?(LOG)
+            @config = { "channel_mappings" => {}, "authorized_role_ids" => [], "authorized_user_ids" => [] }
+          end
+
+          def reload!
+            load!
+          end
+
+          def current
+            @config
+          end
+
+          def default_project
+            @config["default_project"]
+          end
+
+          def owner_discord_id
+            @config["owner_discord_id"]
+          end
+
+          def dashboard_token
+            @config["dashboard_token"]
+          end
+
+          def giphy_api_key
+            @config["giphy_api_key"]
+          end
+
+          def channel_mappings
+            @config["channel_mappings"] || {}
+          end
+
+          def user_mappings
+            @config["user_mappings"] || {}
+          end
+
+          def authorized_role_ids
+            if @config["role_mappings"]
+              @config["role_mappings"].values
+            elsif @config["authorized_role_ids"].is_a?(Hash)
+              @config["authorized_role_ids"].values
+            else
+              @config["authorized_role_ids"] || []
+            end.map(&:to_s)
+          end
+
+          def authorized_user_ids
+            @config["authorized_user_ids"] || []
+          end
+
+          # Find the project for a given Discord channel.
+          # Returns [project_key, project_config, mapping] or nil.
+          def find_project_for_channel(channel_id)
+            mapping = channel_mappings[channel_id]
+
+            unless mapping
+              default = default_project
+              mapping = { "project" => default } if default
+            end
+
+            return nil unless mapping
+
+            project_key = mapping["project"]
+            project_config = PROJECTS[project_key]
+            return nil unless project_config
+
+            [project_key, project_config, mapping]
+          end
+
+          # --- Thread Map Persistence ---
+
+          def load_thread_map
+            return {} unless File.exist?(DISCORD_THREAD_MAP_FILE)
+
+            JSON.parse(File.read(DISCORD_THREAD_MAP_FILE))
+          rescue JSON::ParserError
+            {}
+          end
+
+          def save_thread_map(map)
+            File.write(DISCORD_THREAD_MAP_FILE, JSON.pretty_generate(map))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainiac/plugins/discord/delivery.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord draft delivery system.
+      #
+      # Response files land in draft/ with a .meta.json sidecar containing delivery info.
+      # After successful posting, both files move to posted/.
+      # A poller thread recovers orphaned drafts (e.g. after a server restart).
+      module Delivery
+        BRAINIAC_DIR_PATH = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+        DRAFT_DIR  = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "draft")
+        POSTED_DIR = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "posted")
+
+        POLLER_INTERVAL = 5   # seconds
+        DRAFT_MIN_AGE = 30    # seconds — don't race the monitoring thread
+
+        # Shared thread map: when multiple agents are mentioned in the same message,
+        # the first to deliver creates the thread and stores its ID here so the rest
+        # post into the same thread instead of creating duplicates.
+        @shared_threads = {}
+        @shared_threads_mutex = Mutex.new
+
+        class << self
+          attr_reader :shared_threads, :shared_threads_mutex
+
+          def ensure_dirs!
+            FileUtils.mkdir_p(DRAFT_DIR)
+            FileUtils.mkdir_p(POSTED_DIR)
+          end
+
+          def start_poller!
+            ensure_dirs!
+            Thread.new do
+              LOG.info "[Discord] Draft poller started, checking #{DRAFT_DIR} every #{POLLER_INTERVAL}s" if defined?(LOG)
+              loop do
+                sleep POLLER_INTERVAL
+                poll_drafts
+              rescue StandardError => e
+                LOG.error "[Discord] Draft poller error: #{e.message}" if defined?(LOG)
+              end
+            end
+          end
+
+          # Shared logic for posting a draft response file to Discord and moving it to posted/.
+          def deliver_draft(response_file, meta_file)
+            return false unless File.exist?(meta_file)
+
+            lock_file = "#{meta_file}.lock"
+            begin
+              File.open(lock_file, File::CREAT | File::EXCL | File::WRONLY) {} # rubocop:disable Lint/EmptyBlock
+            rescue Errno::EEXIST
+              return false
+            end
+
+            meta = JSON.parse(File.read(meta_file))
+            bot_token = resolve_bot_token(meta["agent_key"], meta["agent_name"])
+
+            unless bot_token
+              FileUtils.rm_f(lock_file)
+              return false
+            end
+
+            unless File.exist?(response_file)
+              FileUtils.rm_f(lock_file)
+              return false
+            end
+
+            deliver_response_content(response_file, meta, bot_token)
+            archive_delivered(response_file, meta_file, lock_file, meta["agent_name"])
+            true
+          rescue StandardError => e
+            LOG.error "[Discord] Failed to deliver draft #{meta_file}: #{e.message}" if defined?(LOG)
+            File.delete(lock_file) if lock_file && File.exist?(lock_file)
+            false
+          end
+
+          private
+
+          def poll_drafts
+            # Clean up stale lock files (older than 60s) left by crashed deliveries
+            Dir.glob(File.join(DRAFT_DIR, "*.lock")).each do |lock_file|
+              File.delete(lock_file) if (Time.now - File.mtime(lock_file)) > 60
+            end
+
+            Dir.glob(File.join(DRAFT_DIR, "*.meta.json")).each do |meta_file|
+              next if (Time.now - File.mtime(meta_file)) < DRAFT_MIN_AGE
+
+              response_file = if meta_file.end_with?(".md.meta.json")
+                                meta_file.sub(".md.meta.json", ".md")
+                              else
+                                meta_file.sub(".meta.json", ".md")
+                              end
+              next unless File.exist?(response_file)
+
+              LOG.info "[Discord] Poller recovering orphaned draft: #{File.basename(meta_file)}" if defined?(LOG)
+              deliver_draft(response_file, meta_file)
+            end
+          end
+
+          def resolve_bot_token(agent_key, agent_name)
+            token = Gateway.bot_token(agent_key)
+            token ||= (AGENT_REGISTRY.dig(agent_key, "env") || {})["DISCORD_BOT_TOKEN"]
+            LOG.warn "[Discord:#{agent_name}] No bot token found for #{agent_key}, cannot deliver draft" if !token && defined?(LOG)
+            token
+          end
+
+          def deliver_response_content(response_file, meta, bot_token)
+            channel_id = meta["channel_id"]
+            message_id = meta["message_id"]
+            agent_key = meta["agent_key"]
+            agent_name = meta["agent_name"]
+            response = File.read(response_file).strip
+
+            if response.empty?
+              Api.add_reaction(channel_id, message_id, "😶", token: bot_token) if message_id
+              Api.send_message(channel_id, "_#{agent_name} had nothing to say._", token: bot_token)
+            elsif meta["is_dm"] || meta["is_thread"] || message_id.nil?
+              deliver_to_dm_or_forum(response, channel_id, message_id, agent_name, meta, bot_token)
+            else
+              deliver_to_channel_thread(response, channel_id, message_id, agent_key, agent_name, meta["clean_content"] || "", bot_token)
+            end
+          end
+
+          def archive_delivered(response_file, meta_file, lock_file, agent_name)
+            FileUtils.mv(response_file, File.join(POSTED_DIR, File.basename(response_file))) if File.exist?(response_file)
+            FileUtils.mv(meta_file, File.join(POSTED_DIR, File.basename(meta_file)))
+            FileUtils.rm_f(lock_file)
+            LOG.info "[Discord:#{agent_name}] Draft delivered and moved to posted/" if defined?(LOG)
+          end
+
+          def deliver_to_dm_or_forum(response, channel_id, message_id, agent_name, meta, bot_token)
+            if message_id.nil? && Api.forum_channel?(channel_id, token: bot_token)
+              title = meta["forum_title"] || "#{agent_name} — #{Time.now.strftime("%b %d, %Y")}"
+              if meta["forum_reply_to_latest"]
+                latest_thread = Api.find_latest_forum_thread(channel_id, token: bot_token)
+                if latest_thread
+                  Api.send_long_message(latest_thread["id"], response, token: bot_token)
+                else
+                  LOG.warn "[Discord:#{agent_name}] No existing thread found, creating new forum post" if defined?(LOG)
+                  Api.create_forum_post(channel_id, title: title, content: response, token: bot_token)
+                end
+              else
+                Api.create_forum_post(channel_id, title: title, content: response, token: bot_token)
+              end
+            else
+              Api.send_long_message(channel_id, response, token: bot_token)
+            end
+          end
+
+          def deliver_to_channel_thread(response, channel_id, message_id, agent_key, agent_name, clean_content, bot_token)
+            thread_id = nil
+            created_thread = false
+
+            @shared_threads_mutex.synchronize do
+              thread_id = @shared_threads[message_id]
+
+              unless thread_id
+                original_msg = Api.request(:get, "/channels/#{channel_id}/messages/#{message_id}", token: bot_token)
+                if original_msg&.dig("thread", "id")
+                  thread_id = original_msg["thread"]["id"]
+                  @shared_threads[message_id] = thread_id
+                  LOG.info "[Discord:#{agent_name}] Discovered existing thread #{thread_id} on message #{message_id} via API" if defined?(LOG)
+                end
+              end
+
+              unless thread_id
+                display_name = agent_display_name(agent_key)
+                thread = Api.create_thread(channel_id, message_id, name: "#{display_name}: #{clean_content[0..80]}", token: bot_token)
+                if thread && thread["id"]
+                  thread_id = thread["id"]
+                  @shared_threads[message_id] = thread_id
+                  created_thread = true
+                  LOG.info "[Discord:#{agent_name}] Created shared thread #{thread_id} for message #{message_id}" if defined?(LOG)
+                end
+              end
+            end
+
+            if thread_id
+              LOG.info "[Discord:#{agent_name}] Joining shared thread #{thread_id} for message #{message_id}" if !created_thread && defined?(LOG)
+
+              # Propagate dispatch depth to the thread
+              propagate_dispatch_depth(channel_id, thread_id, agent_name)
+
+              Api.send_typing(thread_id, token: bot_token)
+              Api.send_long_message(thread_id, response, token: bot_token)
+            else
+              LOG.warn "[Discord:#{agent_name}] Thread creation failed, falling back to reply" if defined?(LOG)
+              Api.send_long_message(channel_id, response, token: bot_token, reply_to: message_id)
+            end
+          end
+
+          def propagate_dispatch_depth(channel_id, thread_id, agent_name)
+            return unless defined?(AGENT_DISPATCH_DEPTH) && respond_to?(:record_human_comment)
+
+            parent_depth_key = "discord-#{channel_id}"
+            thread_depth_key = "discord-#{thread_id}"
+            parent_info = AGENT_DISPATCH_DEPTH[parent_depth_key]
+            return if AGENT_DISPATCH_DEPTH[thread_depth_key]
+
+            if parent_info
+              AGENT_DISPATCH_DEPTH[thread_depth_key] = { count: 0, last_human_at: parent_info[:last_human_at] }
+              LOG.info "[Discord:#{agent_name}] Propagated dispatch depth from channel #{channel_id} to thread #{thread_id}" if defined?(LOG)
+            else
+              record_human_comment(thread_depth_key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainiac/plugins/discord/gateway.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "websocket-client-simple"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord WebSocket gateway connections.
+      #
+      # Each agent with a DISCORD_BOT_TOKEN gets its own persistent WebSocket
+      # connection. The gateway dispatches MESSAGE_CREATE, MESSAGE_UPDATE,
+      # and MESSAGE_REACTION_ADD events to handler functions.
+      module Gateway
+        GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json"
+
+        # Per-bot state: { agent_key => { token:, user_id:, status:, thread: } }
+        @bots = {}
+        @bots_mutex = Mutex.new
+        @all_ready_logged = false
+
+        class << self
+          attr_reader :bots, :bots_mutex
+
+          def bot_count
+            @bots_mutex.synchronize { @bots.size }
+          end
+
+          # Iterate over bots under mutex.
+          def each_bot(&)
+            @bots_mutex.synchronize do
+              @bots.each(&)
+            end
+          end
+
+          # Get a bot's token.
+          def bot_token(agent_key)
+            @bots_mutex.synchronize { @bots.dig(agent_key, :token) }
+          end
+
+          # Get a bot's user_id.
+          def bot_user_id(agent_key)
+            @bots_mutex.synchronize { @bots.dig(agent_key, :user_id) }
+          end
+
+          # Collect all agent Discord bot tokens from the registry.
+          # Returns { "galen" => "token...", "glados" => "token..." }
+          def discord_bot_tokens
+            tokens = {}
+            AGENT_REGISTRY.each do |key, entry|
+              next unless entry.is_a?(Hash)
+
+              token = (entry["env"] || {})["DISCORD_BOT_TOKEN"]
+              next unless token
+
+              tokens[key] = token
+            end
+            tokens
+          end
+
+          # Start all per-agent Discord bots.
+          def start_all!
+            tokens = discord_bot_tokens
+            if tokens.empty?
+              LOG.info "[Discord] No agents have DISCORD_BOT_TOKEN configured — Discord disabled" if defined?(LOG)
+              return
+            end
+
+            LOG.info "[Discord] Starting #{tokens.size} bot(s): #{tokens.keys.join(", ")}" if defined?(LOG)
+
+            @bots_mutex.synchronize do
+              tokens.each do |agent_key, token|
+                @bots[agent_key] = { token: token, status: "starting", user_id: nil }
+              end
+            end
+
+            tokens.each do |agent_key, token|
+              start_gateway_for(agent_key, token)
+              sleep 1 # Stagger connections to avoid rate limits
+            end
+          end
+
+          # Summary of all bot statuses for the API endpoint.
+          def bots_status
+            @bots_mutex.synchronize do
+              @bots.transform_values do |info|
+                { status: info[:status], user_id: info[:user_id] }
+              end
+            end
+          end
+
+          # Detect if a message author is a known bot (local or remote).
+          # Returns the agent_key of the sender, or nil if unknown.
+          def detect_sender_agent(author, current_agent_key)
+            sender_id = author["id"]
+            sender_agent_key = nil
+
+            @bots_mutex.synchronize do
+              @bots.each do |key, info|
+                if info[:user_id] == sender_id && key != current_agent_key
+                  sender_agent_key = key
+                  break
+                end
+              end
+            end
+
+            unless sender_agent_key
+              Config.user_mappings.each do |name, discord_id|
+                if discord_id == sender_id
+                  sender_agent_key = name.downcase
+                  break
+                end
+              end
+            end
+
+            if !sender_agent_key && defined?(LOG)
+              LOG.info "[Discord:#{current_agent_key}] Ignoring unknown bot: id=#{sender_id}, username=#{author["username"]}"
+            end
+
+            sender_agent_key
+          end
+
+          private
+
+          def start_gateway_for(agent_key, bot_token)
+            Thread.new do
+              agent_display = agent_display_name(agent_key) || agent_key.capitalize
+              bot_user_id = nil
+
+              loop do
+                bot_user_id = run_gateway_connection(agent_key, agent_display, bot_token, bot_user_id)
+              rescue StandardError => e
+                @bots_mutex.synchronize do
+                  @bots[agent_key][:status] = "error" if @bots[agent_key]
+                end
+                LOG.error "[Discord:#{agent_display}] Gateway error: #{e.message}, reconnecting in 5s..." if defined?(LOG)
+                sleep 5
+              end
+            end
+          end
+
+          def run_gateway_connection(agent_key, agent_display, bot_token, bot_user_id)
+            @bots_mutex.synchronize do
+              @bots[agent_key] ||= {}
+              @bots[agent_key][:status] = "connecting"
+              @bots[agent_key][:token] = bot_token
+            end
+
+            LOG.debug "[Discord:#{agent_display}] Connecting to Gateway..." if defined?(LOG) && LOG.respond_to?(:debug)
+            heartbeat_thread = nil
+            last_sequence = nil
+            ws = WebSocket::Client::Simple.connect(GATEWAY_URL)
+
+            ws.on :message do |msg|
+              next if msg.data.nil? || msg.data.empty?
+
+              payload = JSON.parse(msg.data)
+              last_sequence = payload["s"] if payload["s"]
+              heartbeat_thread, bot_user_id = Gateway.send(
+                :handle_gateway_op,
+                ws, payload, agent_key, agent_display, bot_token, bot_user_id, heartbeat_thread, last_sequence
+              )
+            rescue StandardError => e
+              LOG.error "[Discord:#{agent_display}] Gateway message error: #{e.message}" if defined?(LOG)
+            end
+
+            ws.on :open do
+              LOG.debug "[Discord:#{agent_display}] WebSocket connected" if defined?(LOG) && LOG.respond_to?(:debug)
+            end
+
+            ws.on :close do |_e|
+              @bots_mutex.synchronize do
+                @bots[agent_key][:status] = "disconnected" if @bots[agent_key]
+              end
+              LOG.warn "[Discord:#{agent_display}] WebSocket closed" if defined?(LOG)
+              heartbeat_thread&.kill
+            end
+
+            ws.on :error do |e|
+              LOG.error "[Discord:#{agent_display}] WebSocket error: #{e.message}" if defined?(LOG)
+            end
+
+            wait_for_disconnect(ws, agent_display)
+            bot_user_id
+          end
+
+          def wait_for_disconnect(websocket, agent_display)
+            loop do
+              sleep 1
+              next if websocket.open?
+
+              LOG.info "[Discord:#{agent_display}] Connection lost, reconnecting in 5s..." if defined?(LOG)
+              sleep 5
+              break
+            end
+          end
+
+          def handle_gateway_op(websocket, payload, agent_key, agent_display, bot_token, bot_user_id, heartbeat_thread, last_sequence)
+            op = payload["op"]
+            data = payload["d"]
+
+            case op
+            when 10
+              heartbeat_thread = start_heartbeat(websocket, data["heartbeat_interval"], agent_display, last_sequence)
+              send_identify(websocket, bot_token, agent_display)
+            when 0
+              bot_user_id = handle_dispatch(payload, data, agent_key, agent_display, bot_token, bot_user_id)
+            when 1
+              websocket.send({ op: 1, d: last_sequence }.to_json)
+            when 7
+              LOG.info "[Discord:#{agent_display}] Reconnect requested" if defined?(LOG)
+              websocket.close
+            when 9
+              LOG.warn "[Discord:#{agent_display}] Invalid session, re-identifying in 5s" if defined?(LOG)
+              sleep 5
+              send_identify(websocket, bot_token, agent_display)
+            when 11 then nil
+            end
+
+            [heartbeat_thread, bot_user_id]
+          end
+
+          def start_heartbeat(websocket, interval_ms, agent_display, last_sequence)
+            LOG.debug "[Discord:#{agent_display}] Gateway connected, heartbeat: #{interval_ms}ms" if defined?(LOG) && LOG.respond_to?(:debug)
+            Thread.new do
+              loop do
+                sleep(interval_ms / 1000.0)
+                websocket.send({ op: 1, d: last_sequence }.to_json)
+              end
+            end
+          end
+
+          def send_identify(websocket, bot_token, agent_display)
+            LOG.debug "[Discord:#{agent_display}] Sending IDENTIFY" if defined?(LOG) && LOG.respond_to?(:debug)
+            websocket.send({
+              op: 2,
+              d: {
+                token: bot_token,
+                intents: 46_593,
+                properties: { os: RUBY_PLATFORM, browser: "brainiac", device: "brainiac" }
+              }
+            }.to_json)
+          end
+
+          def handle_dispatch(payload, data, agent_key, agent_display, bot_token, bot_user_id)
+            case payload["t"]
+            when "READY"
+              bot_user_id = data.dig("user", "id")
+              mark_bot_ready(agent_key, agent_display, bot_user_id, data)
+            when "MESSAGE_CREATE"
+              Thread.new do
+                Message.handle(data, agent_key, bot_token, bot_user_id)
+              rescue StandardError => e
+                LOG.error "[Discord:#{agent_display}] Error handling message: #{e.message}\n#{e.backtrace.first(3).join("\n")}" if defined?(LOG)
+              end
+            when "MESSAGE_UPDATE"
+              if data["edited_timestamp"]
+                Thread.new do
+                  Message.handle(data, agent_key, bot_token, bot_user_id)
+                rescue StandardError => e
+                  if defined?(LOG)
+                    LOG.error "[Discord:#{agent_display}] Error handling message update: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+                  end
+                end
+              end
+            when "MESSAGE_REACTION_ADD"
+              Thread.new do
+                Reactions.handle(data, agent_key, bot_token, bot_user_id)
+              rescue StandardError => e
+                LOG.error "[Discord:#{agent_display}] Error handling reaction: #{e.message}\n#{e.backtrace.first(3).join("\n")}" if defined?(LOG)
+              end
+            end
+
+            bot_user_id
+          end
+
+          def mark_bot_ready(agent_key, agent_display, bot_user_id, data)
+            @bots_mutex.synchronize do
+              @bots[agent_key][:user_id] = bot_user_id
+              @bots[agent_key][:status] = "ready"
+            end
+            guild_count = data["guilds"]&.size || 0
+            LOG.info "[Discord] #{agent_display} ready (#{guild_count} #{guild_count == 1 ? "guild" : "guilds"})" if defined?(LOG)
+
+            @bots_mutex.synchronize do
+              if !@all_ready_logged && @bots.all? { |_, info| info[:status] == "ready" }
+                @all_ready_logged = true
+                LOG.info "[Discord] All bots connected." if defined?(LOG)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end