brainiac-discord 0.0.21 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0867d7c12ec729c881db2a3a8dd9f02da284f677b3f7226a8771958b97da07b5'
-  data.tar.gz: 073f0bbceca7c578ea06cd888c2e333b113efeede5ebde4b02b257247df15c9d
+  metadata.gz: 2b8cac77bcff754559623d7dc4b787a4fb405c8e34924b59fcd24a9d3db58d70
+  data.tar.gz: 027f50b17e55e46aa58c7305e62834b953054515c77da6a803ece5f90b5c3d35
 SHA512:
-  metadata.gz: 5c103f0b92d230a5789424e41d9ea9881636a7ede849278db072c93b42c18ac42266ea264abb7128086e92e0639a042ff894460d9ee1405aabb5348d71918bda
-  data.tar.gz: 2a236d41ec8676a4e3459bcd26bf5d47019a3f4cc5e67bfa4b1d2b8027c00e0803680c5ca37166285449d4a0f2ccffd7a0b81fde785a4ea977f476994aa158d3
+  metadata.gz: 80215591d21d89f226ae08f7c1ef246a7730bb36b9e71592f3b5ad06fdeee750c3e68508b8fd25071fb450754401946b614e8b28b9665660b8bf16f1b6a4a5c5
+  data.tar.gz: 543f0b0d398e220b8e9927b0638a2e67780f6bdf48375456d13a741faed14bc4bc2b51ac95a6fce3a2f2c85f846591b4c08381d0579d2b567a43a0860849d279

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "base64"
+require "fileutils"
+require "json"
+require "net/http"
+require "uri"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Provisions a Discord bot for a new brainiac agent (`brainiac agent create`
+      # / `brainiac agent setup`).
+      #
+      # Discord has no API for creating applications, so the one manual step is
+      # "New Application → Bot → Reset Token" in the developer portal. Given that
+      # token, everything else is automated: bot username + avatar, app icon +
+      # description, the Message Content intent, the token in agents.json, the
+      # user_mappings entry, and the server invite link.
+      module AgentSetup
+        API_BASE = "https://discord.com/api/v10"
+        PORTAL_URL = "https://discord.com/developers/applications"
+
+        # Application flags that PATCH /applications/@me is allowed to change.
+        GATEWAY_PRESENCE_LIMITED = 1 << 13
+        GATEWAY_GUILD_MEMBERS_LIMITED = 1 << 15
+        GATEWAY_MESSAGE_CONTENT_LIMITED = 1 << 19
+        EDITABLE_FLAGS = GATEWAY_PRESENCE_LIMITED | GATEWAY_GUILD_MEMBERS_LIMITED | GATEWAY_MESSAGE_CONTENT_LIMITED
+
+        # View channels, send/read messages, embeds, files, reactions, threads.
+        BOT_PERMISSIONS = [10, 11, 14, 15, 16, 6, 34, 35, 38].sum { |bit| 1 << bit }
+
+        APP_DESCRIPTION_LIMIT = 400
+        IMAGE_TYPES = { ".png" => "image/png", ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg",
+                        ".gif" => "image/gif", ".webp" => "image/webp" }.freeze
+
+        class << self
+          def run(agent_key, entry)
+            display_name = entry["display_name"] || agent_key.capitalize
+            token = registry.dig(agent_key, "env", "DISCORD_BOT_TOKEN")
+
+            if token && discord_config.dig("user_mappings", display_name)
+              puts "  [Discord] ✓ #{display_name} already has a bot (skipping)"
+              return
+            end
+
+            token ||= prompt_for_token(display_name, entry["open_browser"])
+            return unless token
+
+            me = request(:get, "/users/@me", token)
+            unless me&.dig("id")
+              puts "  [Discord] ✗ Discord rejected that token — re-run: brainiac agent setup #{agent_key}"
+              return
+            end
+
+            avatar = image_data_uri(entry["avatar_path"])
+            update_bot_user(me, display_name, avatar, token)
+            app = request(:get, "/applications/@me", token) || {}
+            update_application(app, entry["description"], avatar, token)
+
+            save_token(agent_key, token)
+            save_user_mapping(display_name, me["id"])
+            puts "  [Discord] ✓ Saved DISCORD_BOT_TOKEN and user_mappings[#{display_name}] = #{me["id"]}"
+            puts "  [Discord] Invite #{display_name} to your server:"
+            puts "    #{invite_url(app["id"] || me["id"])}"
+            open_url(invite_url(app["id"] || me["id"])) if entry["open_browser"]
+          end
+
+          private
+
+          def prompt_for_token(display_name, browser)
+            return nil unless $stdin.tty?
+
+            puts ""
+            puts "  [Discord] Opening the developer portal in your browser…" if browser && open_url(PORTAL_URL)
+            puts "  [Discord] Create a bot for #{display_name} (the only manual step):"
+            puts "    1. #{PORTAL_URL} → New Application → name it \"#{display_name}\""
+            puts "    2. Bot tab → Reset Token → copy it"
+            puts "  Name, avatar, description and Message Content intent are set automatically."
+            print "  Bot token (blank to skip): "
+            token = read_secret
+            puts ""
+            token.nil? || token.empty? ? nil : token
+          end
+
+          # Best-effort: launch the default browser without blocking on it.
+          # Returns false when no launcher is available (headless, SSH, ...).
+          def open_url(url)
+            launcher = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+            pid = Process.spawn(launcher, url, %i[out err] => File::NULL)
+            Process.detach(pid)
+            true
+          rescue SystemCallError
+            false
+          end
+
+          def read_secret
+            require "io/console"
+            $stdin.noecho(&:gets)&.strip
+          rescue Errno::ENOTTY, NoMethodError
+            $stdin.gets&.strip
+          end
+
+          def update_bot_user(bot_user, display_name, avatar, token)
+            body = {}
+            body[:username] = display_name unless bot_user["username"] == display_name
+            body[:avatar] = avatar if avatar
+            return if body.empty?
+
+            if request(:patch, "/users/@me", token, body)
+              puts "  [Discord] ✓ Bot user: #{body.keys.join(" + ")} updated"
+            else
+              puts "  [Discord] ⚠ Couldn't update bot #{body.keys.join("/")} (username taken or rate limited?) — set it in the portal"
+            end
+          end
+
+          def update_application(app, description, avatar, token)
+            body = {}
+            body[:description] = truncate(description, APP_DESCRIPTION_LIMIT) if description
+            body[:icon] = avatar if avatar
+            if body.any? && !request(:patch, "/applications/@me", token, body)
+              puts "  [Discord] ⚠ Couldn't update app #{body.keys.join("/")} — set it in the portal"
+            end
+
+            # Separate request so a flags rejection doesn't lose the icon/description.
+            flags = ((app["flags"] || 0) & EDITABLE_FLAGS) | GATEWAY_MESSAGE_CONTENT_LIMITED
+            if request(:patch, "/applications/@me", token, { flags: flags })
+              puts "  [Discord] ✓ App #{(body.keys + [:message_content_intent]).join(" + ")} set"
+            else
+              puts "  [Discord] ⚠ Couldn't enable Message Content intent — Bot tab → Privileged Gateway Intents"
+            end
+          end
+
+          def invite_url(client_id)
+            "https://discord.com/oauth2/authorize?client_id=#{client_id}&scope=bot&permissions=#{BOT_PERMISSIONS}"
+          end
+
+          def image_data_uri(path)
+            return nil unless path && File.file?(path)
+
+            mime = IMAGE_TYPES[File.extname(path).downcase]
+            return nil unless mime
+
+            "data:#{mime};base64,#{Base64.strict_encode64(File.binread(path))}"
+          end
+
+          def truncate(text, limit)
+            text = text.strip
+            text.length > limit ? "#{text[0, limit - 1].rstrip}…" : text
+          end
+
+          # Returns the parsed body on 2xx, nil otherwise.
+          def request(method, path, token, body = nil)
+            uri = URI("#{API_BASE}#{path}")
+            klass = { get: Net::HTTP::Get, patch: Net::HTTP::Patch }.fetch(method)
+            req = klass.new(uri)
+            req["Authorization"] = "Bot #{token}"
+            req["Content-Type"] = "application/json"
+            req["User-Agent"] = "DiscordBot (https://github.com/stowzilla/brainiac-discord, 1.0)"
+            req.body = body.to_json if body
+
+            response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
+            return nil unless response.is_a?(Net::HTTPSuccess)
+
+            response.body.to_s.empty? ? {} : JSON.parse(response.body)
+          rescue StandardError
+            nil
+          end
+
+          def brainiac_dir
+            ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
+          end
+
+          def registry_file = File.join(brainiac_dir, "agents.json")
+          def config_file = File.join(brainiac_dir, "discord.json")
+
+          def registry
+            File.exist?(registry_file) ? JSON.parse(File.read(registry_file)) : {}
+          end
+
+          def discord_config
+            File.exist?(config_file) ? JSON.parse(File.read(config_file)) : {}
+          end
+
+          def save_token(agent_key, token)
+            reg = registry
+            reg[agent_key] ||= {}
+            reg[agent_key]["env"] ||= {}
+            reg[agent_key]["env"]["DISCORD_BOT_TOKEN"] = token
+            FileUtils.mkdir_p(brainiac_dir)
+            File.write(registry_file, JSON.pretty_generate(reg))
+          end
+
+          def save_user_mapping(display_name, user_id)
+            config = discord_config
+            config["user_mappings"] ||= {}
+            config["user_mappings"][display_name] = user_id
+            File.write(config_file, JSON.pretty_generate(config))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@
 require "json"
 require "net/http"
 require "uri"
+require_relative "agent_setup"
 
 module Brainiac
   module Plugins
@@ -270,25 +271,12 @@ module Brainiac
         %w[setup config default map owner token status]
       end
 
-      # Called by brainiac CLI after `agent create` — prompts for Discord user ID.
+      # Called by brainiac CLI after `agent create` / `agent setup` — provisions
+      # the agent's Discord bot (see AgentSetup). Safe to re-run.
       def self.on_agent_created(agent_key, entry)
-        return unless $stdin.tty?
-
-        display_name = entry["display_name"] || agent_key.capitalize
-        puts ""
-        puts "  [Discord] Configure Discord for #{display_name}?"
-        print "  Discord user ID (or blank to skip): "
-        user_id = $stdin.gets&.chomp
-        return if user_id.nil? || user_id.empty?
-
-        config_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "discord.json")
-        config = File.exist?(config_file) ? JSON.parse(File.read(config_file)) : {}
-        config["user_mappings"] ||= {}
-        config["user_mappings"][display_name] = user_id
-        File.write(config_file, JSON.pretty_generate(config))
-        puts "  ✓ Added #{display_name} → #{user_id} to discord.json user_mappings"
+        AgentSetup.run(agent_key, entry)
       rescue JSON::ParserError => e
-        puts "  ⚠ Could not update discord.json: #{e.message}"
+        puts "  ⚠ Could not update Discord config: #{e.message}"
       end
 
       # Called by brainiac CLI after `agent remove` — removes from Discord user_mappings.

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

@@ -714,8 +714,15 @@ module Brainiac
           end
 
           def resolve_overrides(clean_content, project_config, thread_model, thread_effort, thread_cli_provider)
-            cli_provider = detect_cli_provider(text: clean_content) || thread_cli_provider
+            inline_cli = detect_cli_provider(text: clean_content)
+            cli_provider = inline_cli || thread_cli_provider
             has_explicit_model = explicit_model_tag?(clean_content, project_config, cli_provider_override: cli_provider)
+
+            # The stored model is a resolved ID from the previous provider's model map, so it
+            # means nothing to a different provider. Drop it on a switch and fall back to the
+            # new provider's default (unless this message also carries a model tag).
+            # Effort is kept: it's generic and gets clamped per provider anyway.
+            thread_model = nil if provider_switched?(inline_cli, thread_cli_provider)
             has_explicit_effort = clean_content.match?(/\[effort:\w+\]/i)
 
             model = if has_explicit_model
@@ -737,6 +744,10 @@ module Brainiac
             [model, effort, cli_provider]
           end
 
+          def provider_switched?(inline_cli, prev_cli_provider)
+            !inline_cli.nil? && inline_cli != prev_cli_provider
+          end
+
           # Persist inline overrides to the thread map (and work item map if a work item exists).
           # Only writes when a new inline tag was detected (differs from previously stored values).
           def persist_overrides(thread_map_key, clean_content, project_config,
@@ -761,7 +772,8 @@ module Brainiac
               entry = map[thread_map_key]
               if entry
                 entry["cli_provider"] = cli_provider if inline_cli
-                entry["model"] = model if inline_model
+                # Clear the old provider's model on a switch so it can't resurface later
+                entry["model"] = inline_model if inline_model || provider_switched?(inline_cli, prev_cli_provider)
                 entry["effort"] = effort if inline_effort
                 Config.save_thread_map(map)
               end

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.21"
+      VERSION = "0.0.23"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-discord
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.23
 platform: ruby
 authors:
 - Andy Davis
@@ -103,6 +103,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/brainiac/plugins/discord.rb
+- lib/brainiac/plugins/discord/agent_setup.rb
 - lib/brainiac/plugins/discord/api.rb
 - lib/brainiac/plugins/discord/branching.rb
 - lib/brainiac/plugins/discord/cli.rb