brainiac-discord 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 223dd60e819a0b61ff8b4f82e27cf88774d431b2a2673f82e5e5d7724ca6ed9b
+  data.tar.gz: 1777674edaec7db3e0772bdc3fa55d3f7438b1c0fba4c2450c50cd78ffa46442
+SHA512:
+  metadata.gz: 3a2f08e64fa903bd185a7c4a09a279a5dd23425b744e59f0e5e4bd17bc7d9adb841bef15d7f1c09b614ff89587fac1ed01a11bf38edb10059e06956e21816358
+  data.tar.gz: 3dd471e951c05a947837a55ab5f9c6510e798eb41d2d86c65ab13c0264b29804e48de6cf430654639d5076db912c1093bee6578ad307a0bde56ad51a51309cb8

data/README.md

@@ -0,0 +1,110 @@
+# brainiac-discord
+
+Discord bot plugin for [Brainiac](https://github.com/stowzilla/brainiac) — the AI agent orchestration platform.
+
+Each agent gets its own Discord bot. Users @mention @Galen or @GLaDOS directly — no shared bot, no agent name detection needed.
+
+## Features
+
+- **Per-agent bots** — each agent with a `DISCORD_BOT_TOKEN` gets its own WebSocket gateway connection
+- **Session supersede** — follow-up messages within 60s kill the previous run and restart with updated context
+- **Cancel via ❌** — react to cancel an active agent session
+- **Thinking peek** — react ❔/❓ to see the last 10/20 lines of agent output
+- **Thinking stream** — react 🧠 to get the full agent log streamed to a thread
+- **Emoji feedback** — non-reserved emoji reactions are logged as feedback to the agent's persona
+- **Thread isolation** — conversations get their own threads with worktree persistence
+- **Forum support** — cron jobs can post to forum channels
+- **GIF support** — agents can search and embed GIFs via GIPHY API
+- **Draft delivery** — file-based response delivery survives server restarts
+
+## Installation
+
+```bash
+brainiac install discord
+brainiac restart
+```
+
+Or for local development:
+
+```bash
+brainiac install discord --path ~/Code/brainiac-discord
+brainiac restart
+```
+
+## Setup
+
+### 1. Create Discord Applications
+
+Create one Discord application per agent at https://discord.com/developers/applications:
+
+1. Click "New Application", name it after the agent
+2. Go to "Bot" tab → enable **Message Content Intent**
+3. Copy the bot token
+
+### 2. Register Tokens
+
+```bash
+brainiac discord token galen "BOT_TOKEN_FOR_GALEN"
+brainiac discord token glados "BOT_TOKEN_FOR_GLADOS"
+```
+
+### 3. Invite Bots
+
+Use the OAuth2 URL Generator with `bot` scope and these permissions:
+- Send Messages, Create Public Threads, Send Messages in Threads
+- Add Reactions, Read Message History
+
+Permission integer: `326417591296`
+
+### 4. Configure
+
+Set a default project:
+```bash
+brainiac discord default marketplace
+```
+
+Map channels to projects:
+```bash
+brainiac discord map 1234567890 brainiac
+```
+
+### 5. Start
+
+```bash
+brainiac server
+```
+
+All bots connect automatically as background threads.
+
+## Configuration
+
+Stored in `~/.brainiac/discord.json`:
+
+```json
+{
+  "default_project": "marketplace",
+  "owner_discord_id": "YOUR_DISCORD_USER_ID",
+  "channel_mappings": {
+    "0987654321": { "project": "brainiac" }
+  },
+  "user_mappings": {
+    "Andy": "123456789012345678"
+  },
+  "authorized_role_ids": [],
+  "authorized_user_ids": [],
+  "giphy_api_key": "your-giphy-api-key"
+}
+```
+
+## Development
+
+```bash
+cd ~/Code/brainiac-discord
+bundle install
+rake test
+rake rubocop
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord REST API helpers.
+      #
+      # Low-level HTTP methods and convenience wrappers for the Discord v10 API.
+      # Used by the Discord handler itself, but also available for other plugins
+      # (e.g. GitHub deploy notifications, Zoho email notifications).
+      module Api
+        DISCORD_API_BASE = "https://discord.com/api/v10"
+
+        # Emojis reserved for brainiac functionality — not treated as feedback
+        RESERVED_EMOJIS = %w[👀 ❌ 🛑 🚫 ⚠️ ⏳ 😶 ❔ ❓ 🧠].freeze
+
+        class << self
+          def request(method, path, token:, body: nil, log_errors: true)
+            uri = URI("#{DISCORD_API_BASE}#{path}")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+
+            req = case method
+                  when :get    then Net::HTTP::Get.new(uri)
+                  when :post   then Net::HTTP::Post.new(uri)
+                  when :put    then Net::HTTP::Put.new(uri)
+                  when :delete then Net::HTTP::Delete.new(uri)
+                  end
+
+            req["Authorization"] = "Bot #{token}"
+            req["Content-Type"] = "application/json"
+            req.body = body.to_json if body
+
+            response = http.request(req)
+
+            if response.code.to_i == 429
+              retry_after = JSON.parse(response.body)["retry_after"] || 1
+              LOG.warn "[Discord] Rate limited, waiting #{retry_after}s" if defined?(LOG)
+              sleep retry_after
+              return request(method, path, token: token, body: body, log_errors: log_errors)
+            end
+
+            if response.code.to_i >= 400 && log_errors && defined?(LOG)
+              LOG.error "[Discord] API error (#{method} #{path}): HTTP #{response.code} - #{response.body}"
+            end
+
+            JSON.parse(response.body) unless response.body.nil? || response.body.empty?
+          rescue StandardError => e
+            LOG.error "[Discord] API error (#{method} #{path}): #{e.message}" if log_errors && defined?(LOG)
+            nil
+          end
+
+          # --- Channel & Message Operations ---
+
+          def fetch_channel_history(channel_id, before_message_id, token:, limit: 10)
+            messages = request(:get, "/channels/#{channel_id}/messages?before=#{before_message_id}&limit=#{limit}", token: token)
+
+            all_messages = messages.is_a?(Array) ? messages : []
+
+            if all_messages.any?
+              oldest = all_messages.last
+              all_messages << oldest["referenced_message"] if oldest && oldest["type"] == 21 && oldest["referenced_message"]
+            end
+
+            return "" if all_messages.empty?
+
+            lines = all_messages.reverse.filter_map do |msg|
+              author = msg.dig("author", "username") || "unknown"
+              content = msg["content"]&.strip || ""
+              next if content.empty?
+
+              "#{author}: #{content}"
+            end
+
+            return "" if lines.empty?
+
+            lines.join("\n")
+          rescue StandardError => e
+            LOG.warn "[Discord] Failed to fetch channel history: #{e.message}" if defined?(LOG)
+            ""
+          end
+
+          def fetch_channel_info(channel_id, token:)
+            request(:get, "/channels/#{channel_id}", token: token)
+          end
+
+          def fetch_message(channel_id, message_id, token:, log_errors: true)
+            request(:get, "/channels/#{channel_id}/messages/#{message_id}", token: token, log_errors: log_errors)
+          end
+
+          def fetch_guild_member(guild_id, user_id, token:)
+            request(:get, "/guilds/#{guild_id}/members/#{user_id}", token: token)
+          end
+
+          # --- Messaging ---
+
+          def send_message(channel_id, content, token:, reply_to: nil)
+            body = { content: content }
+            body[:message_reference] = { message_id: reply_to } if reply_to
+            result = request(:post, "/channels/#{channel_id}/messages", token: token, body: body)
+            if result && result["id"]
+              LOG.info "[Discord] Message posted to channel #{channel_id}, message_id: #{result["id"]}" if defined?(LOG)
+            elsif defined?(LOG)
+              LOG.error "[Discord] Failed to post message to channel #{channel_id}, result: #{result.inspect}"
+            end
+            result
+          end
+
+          def send_long_message(channel_id, content, token:, reply_to: nil)
+            if content.length <= 2000
+              send_message(channel_id, content, token: token, reply_to: reply_to)
+              return
+            end
+
+            chunks = split_content(content)
+            chunks.each_with_index do |chunk, i|
+              send_message(channel_id, chunk, token: token, reply_to: i.zero? ? reply_to : nil)
+              sleep 0.5
+            end
+          end
+
+          def send_typing(channel_id, token:)
+            request(:post, "/channels/#{channel_id}/typing", token: token)
+          end
+
+          # --- Reactions ---
+
+          def add_reaction(channel_id, message_id, emoji, token:)
+            encoded = URI.encode_www_form_component(emoji)
+            request(:put, "/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me", token: token)
+          end
+
+          def remove_reaction(channel_id, message_id, emoji, token:)
+            encoded = URI.encode_www_form_component(emoji)
+            request(:delete, "/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me", token: token)
+          end
+
+          # --- Threads & Forums ---
+
+          def create_thread(channel_id, message_id, name:, token:)
+            thread_name = name.length > 100 ? "#{name[0..96]}..." : name
+            request(:post, "/channels/#{channel_id}/messages/#{message_id}/threads", token: token, body: {
+                      name: thread_name,
+                      auto_archive_duration: 1440
+                    })
+          end
+
+          def forum_channel?(channel_id, token:)
+            info = fetch_channel_info(channel_id, token: token)
+            info && info["type"] == 15
+          end
+
+          def find_latest_forum_thread(channel_id, token:)
+            channel_info = fetch_channel_info(channel_id, token: token)
+            return nil unless channel_info && channel_info["guild_id"]
+
+            guild_id = channel_info["guild_id"]
+            result = request(:get, "/guilds/#{guild_id}/threads/active", token: token)
+            return nil unless result && result["threads"]
+
+            forum_threads = result["threads"]
+                            .select { |t| t["parent_id"] == channel_id }
+                            .sort_by { |t| t["id"].to_i }
+                            .reverse
+
+            return nil if forum_threads.empty?
+
+            latest = forum_threads.first
+            LOG.info "[Discord] Found latest forum thread: #{latest["id"]} (#{latest["name"]}) in channel #{channel_id}" if defined?(LOG)
+            latest
+          end
+
+          def create_forum_post(channel_id, title:, content:, token:)
+            thread_name = title.length > 100 ? "#{title[0..96]}..." : title
+            result = request(:post, "/channels/#{channel_id}/threads", token: token, body: {
+                               name: thread_name,
+                               message: { content: content },
+                               auto_archive_duration: 1440
+                             })
+            if result && result["id"]
+              LOG.info "[Discord] Forum post created in channel #{channel_id}, thread_id: #{result["id"]}" if defined?(LOG)
+            elsif defined?(LOG)
+              LOG.error "[Discord] Failed to create forum post in channel #{channel_id}, result: #{result.inspect}"
+            end
+            result
+          end
+
+          # --- GIF Search ---
+
+          def search_gif(query)
+            api_key = Config.giphy_api_key
+            return [] unless api_key
+
+            uri = URI("https://api.giphy.com/v1/gifs/search")
+            uri.query = URI.encode_www_form(api_key: api_key, q: query, limit: 5, rating: "pg-13")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            response = http.get(uri)
+            return [] unless response.code.to_i == 200
+
+            data = JSON.parse(response.body)
+            (data["data"] || []).map { |g| { "url" => g.dig("images", "original", "url") || g["url"] } }
+          rescue StandardError => e
+            LOG.warn "[Discord] GIF search error: #{e.message}" if defined?(LOG)
+            []
+          end
+
+          # --- Helpers ---
+
+          def find_root_message(message, channel_id, bot_token)
+            current_msg = message
+            visited = Set.new
+            max_depth = 20
+            walked = false
+
+            max_depth.times do
+              msg_id = current_msg["id"]
+              return { id: msg_id, content: nil, author: nil } if visited.include?(msg_id)
+
+              visited << msg_id
+
+              ref = current_msg["message_reference"]
+              break unless ref
+
+              ref_msg_id = ref["message_id"]
+              ref_channel = ref["channel_id"] || channel_id
+              break unless ref_msg_id
+
+              referenced = request(:get, "/channels/#{ref_channel}/messages/#{ref_msg_id}", token: bot_token)
+              break unless referenced
+
+              current_msg = referenced
+              walked = true
+            end
+
+            {
+              id: current_msg["id"],
+              content: walked ? current_msg["content"]&.strip : nil,
+              author: walked ? current_msg.dig("author", "username") : nil
+            }
+          end
+
+          # Build a Discord mention roster so the agent can @mention people and other bots.
+          def mention_roster
+            lines = []
+
+            Gateway.each_bot do |agent_key, info|
+              next unless info[:user_id]
+
+              display = agent_display_name(agent_key) || agent_key.capitalize
+              lines << "  - #{display}: `<@#{info[:user_id]}>`"
+            end
+
+            Config.user_mappings.each do |name, discord_id|
+              lines << "  - #{name}: `<@#{discord_id}>`"
+            end
+
+            lines.join("\n")
+          end
+
+          private
+
+          def split_content(content)
+            chunks = []
+            remaining = content
+            while remaining.length.positive?
+              if remaining.length <= 2000
+                chunks << remaining
+                remaining = ""
+              else
+                split_at = remaining.rindex("\n", 1990) || 1990
+                chunks << remaining[0...split_at]
+                remaining = remaining[split_at..].lstrip
+              end
+            end
+            chunks
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # CLI subcommands for brainiac-discord plugin.
+      #
+      # Invoked when a user runs `brainiac discord <command>`.
+      # Manages discord.json config and agent bot tokens.
+      module Cli
+        BRAINIAC_DIR = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+        DISCORD_CONFIG_FILE = File.join(BRAINIAC_DIR, "discord.json")
+        AGENT_REGISTRY_FILE = File.join(BRAINIAC_DIR, "agents.json")
+
+        class << self
+          def run(args)
+            command = args.shift
+
+            case command
+            when "config"
+              cmd_config
+            when "map"
+              cmd_map(args)
+            when "default"
+              cmd_default(args)
+            when "token"
+              cmd_token(args)
+            when "status"
+              cmd_status
+            when "owner"
+              cmd_owner(args)
+            when "setup"
+              cmd_setup
+            else
+              print_help
+            end
+          end
+
+          private
+
+          def cmd_config
+            if File.exist?(DISCORD_CONFIG_FILE)
+              puts File.read(DISCORD_CONFIG_FILE)
+            else
+              puts "No Discord config found at #{DISCORD_CONFIG_FILE}"
+              puts "Run 'brainiac discord setup' to configure Discord."
+            end
+          end
+
+          def cmd_map(args)
+            channel_id = args[0]
+            project_key = args[1]
+
+            unless channel_id && project_key
+              puts "Usage: brainiac discord map <channel-id> <project-key>"
+              exit 1
+            end
+
+            config = load_discord_config
+            config["channel_mappings"] ||= {}
+            config["channel_mappings"][channel_id] = { "project" => project_key }
+
+            save_discord_config(config)
+            puts "✓ Mapped channel #{channel_id} → project '#{project_key}'"
+          end
+
+          def cmd_default(args)
+            project_key = args[0]
+
+            unless project_key
+              puts "Usage: brainiac discord default <project-key>"
+              exit 1
+            end
+
+            config = load_discord_config
+            config["default_project"] = project_key
+
+            save_discord_config(config)
+            puts "✓ Default project: #{project_key}"
+          end
+
+          def cmd_token(args)
+            agent_key = args[0]
+            token = args[1]
+
+            unless agent_key && token
+              puts "Usage: brainiac discord token <agent-key> <bot-token>"
+              puts "  Sets the DISCORD_BOT_TOKEN env var for an agent in the registry."
+              puts "  Example: brainiac discord token galen Bot_TOKEN_HERE"
+              exit 1
+            end
+
+            registry = File.exist?(AGENT_REGISTRY_FILE) ? JSON.parse(File.read(AGENT_REGISTRY_FILE)) : {}
+            registry[agent_key] ||= {}
+            registry[agent_key]["env"] ||= {}
+            registry[agent_key]["env"]["DISCORD_BOT_TOKEN"] = token
+
+            FileUtils.mkdir_p(BRAINIAC_DIR)
+            File.write(AGENT_REGISTRY_FILE, JSON.pretty_generate(registry))
+            puts "✓ Set DISCORD_BOT_TOKEN for '#{agent_key}'"
+          end
+
+          def cmd_status
+            server_url = detect_server_url
+            begin
+              uri = URI("#{server_url}/api/discord")
+              response = Net::HTTP.get_response(uri)
+              data = JSON.parse(response.body)
+              if data["enabled"]
+                bots = data["bots"] || {}
+                if bots.empty?
+                  puts "Discord: enabled but no bots configured"
+                else
+                  puts "Discord bots:"
+                  bots.each do |agent, info|
+                    puts "  #{agent}: #{info["status"]} (user_id: #{info["user_id"] || "n/a"})"
+                  end
+                end
+                puts "Default project: #{data.dig("config", "default_project") || "none"}"
+                puts "Channel mappings: #{data.dig("config", "channel_mappings")}"
+              else
+                puts "Discord: disabled (#{data["reason"]})"
+              end
+            rescue StandardError => e
+              puts "Could not reach server at #{server_url}: #{e.message}"
+              puts "Is the server running? Check with: brainiac status"
+            end
+          end
+
+          def cmd_owner(args)
+            discord_id = args[0]
+            config = load_discord_config
+            if discord_id
+              config["owner_discord_id"] = discord_id
+              save_discord_config(config)
+              puts "✓ Owner set to #{discord_id}"
+            elsif config["owner_discord_id"]
+              puts "Owner: #{config["owner_discord_id"]}"
+            else
+              puts "No owner set."
+              puts "Usage: brainiac discord owner <discord-user-id>"
+            end
+          end
+
+          def cmd_setup
+            puts "Discord Setup"
+            puts "============="
+            puts ""
+
+            # Copy example config if none exists
+            unless File.exist?(DISCORD_CONFIG_FILE)
+              template = File.expand_path("../../../../templates/discord.json.example", __dir__)
+              if File.exist?(template)
+                FileUtils.mkdir_p(BRAINIAC_DIR)
+                FileUtils.cp(template, DISCORD_CONFIG_FILE)
+                puts "✓ Created #{DISCORD_CONFIG_FILE} from template"
+                puts ""
+              end
+            end
+
+            config = load_discord_config
+
+            if config["default_project"]
+              puts "✓ Default project: #{config["default_project"]}"
+            else
+              puts "⚠ No default project set."
+              puts "  Set one with: brainiac discord default <project-key>"
+            end
+            puts ""
+
+            registry = File.exist?(AGENT_REGISTRY_FILE) ? JSON.parse(File.read(AGENT_REGISTRY_FILE)) : {}
+            agents_with_tokens = registry.select { |_k, v| v.is_a?(Hash) && v.dig("env", "DISCORD_BOT_TOKEN") }
+            if agents_with_tokens.any?
+              puts "✓ #{agents_with_tokens.size} agent(s) have Discord bot tokens:"
+              agents_with_tokens.each do |key, entry|
+                display = entry["display_name"] || key.capitalize
+                puts "    #{display} (#{key})"
+              end
+            else
+              puts "⚠ No agents have Discord bot tokens configured."
+              puts "  Add one with: brainiac discord token <agent-key> <bot-token>"
+              puts ""
+              puts "  To get a bot token:"
+              puts "  1. Go to https://discord.com/developers/applications"
+              puts "  2. Create a new application (one per agent)"
+              puts "  3. Go to Bot tab → Copy token"
+              puts "  4. Enable MESSAGE CONTENT intent"
+            end
+            puts ""
+
+            mappings = config["channel_mappings"] || {}
+            if mappings.any?
+              puts "✓ #{mappings.size} channel mapping(s) configured"
+            else
+              puts "  No channel mappings (using default project for all channels)"
+              puts "  Optionally map specific channels: brainiac discord map <channel-id> <project>"
+            end
+            puts ""
+
+            if agents_with_tokens.any? && config["default_project"]
+              puts "✓ Discord is configured! Start with: brainiac server"
+            else
+              puts "Complete the steps above, then start with: brainiac server"
+            end
+          end
+
+          def print_help
+            puts <<~HELP
+              Usage: brainiac discord <command>
+
+              Commands:
+                setup                               Interactive setup guide
+                config                              Show Discord config
+                default <project>                   Set default project for all channels
+                map <channel-id> <project>          Map a specific channel to a project
+                owner [<discord-user-id>]           Set/show machine owner (for version notifications)
+                token <agent-key> <bot-token>       Set Discord bot token for an agent
+                status                              Check Discord bot status (via server API)
+
+              Each agent gets its own Discord bot. Users @mention @Galen or @GLaDOS
+              directly in Discord — no shared bot needed.
+
+              Quick start:
+                brainiac discord token galen "BOT_TOKEN_FOR_GALEN"
+                brainiac discord default marketplace
+                brainiac server
+            HELP
+          end
+
+          def load_discord_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
+            { "channel_mappings" => {}, "authorized_role_ids" => [], "authorized_user_ids" => [] }
+          end
+
+          def save_discord_config(config)
+            FileUtils.mkdir_p(BRAINIAC_DIR)
+            File.write(DISCORD_CONFIG_FILE, JSON.pretty_generate(config))
+          end
+
+          def detect_server_url
+            config_file = File.join(BRAINIAC_DIR, "brainiac.json")
+            if File.exist?(config_file)
+              config = JSON.parse(File.read(config_file))
+              config["server_url"] || "http://localhost:4567"
+            else
+              "http://localhost:4567"
+            end
+          rescue JSON::ParserError
+            "http://localhost:4567"
+          end
+        end
+      end
+
+      # Plugin CLI entry point — called by brainiac core's plugin delegation.
+      def self.cli(args)
+        Cli.run(args)
+      end
+
+      # Subcommand names for bash completion.
+      def self.completions
+        %w[setup config default map owner token status]
+      end
+    end
+  end
+end