onyxcord 2.0.5 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e5d5e025fe9ad9abb42d0fca6da5fe8bf9f32bfbe527de27a2da742bfe5f262
-  data.tar.gz: e7b494fd1d4821c2c517f24ceca4a6da27720f552618b71f5a5452c5a3ef915b
+  metadata.gz: de906b93116b1c325312db44d7373011c24b4ea6807cea759112af2846a9449a
+  data.tar.gz: 3be86bc11a833fd3cb8b88874837d2cc732c916a4b6f4afbad340f1573531f89
 SHA512:
-  metadata.gz: '059ec009fb6fd52704a2906bdfc8fb6a20f0e06dd2ac783e1f466ce4cfabbe71c2fa9cb269a332e69fc3a05cdef7d8e394cfc3a3e1bfb11c94c0c7d43c0dd26d'
-  data.tar.gz: c4f5fb863ec9a636d4b7591b50afe16d4a0174c28390f5d42aa84f7ff32a2e904cfe71de4104b4425a7661cb82e71a9b114abc6b874888c52d8ad74683f14d58
+  metadata.gz: b7c429540a55956bb417841e610d9e8da946d18c4565c3177a45cb2ec4ba885988e02fade2c910edff015aee77970709198d450ba5719faa1862a182ab3507fb
+  data.tar.gz: 8159656f82928ec348522857df842cfe27479c6ba147e090778ac26749533f7d0c32c80390b61df6e4b15ef485fa2e6dcb886355650cc2cb1f2598759f694da9

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.0.8 - 2026-06-28
+
+### Correcoes de gateway
+
+- Forca WebSocket do Gateway e do cliente generico em HTTP/1.1 para evitar `Async::WebSocket::ConnectionError: Failed to negotiate connection!` ao conectar no Discord.
+- Desativa extensoes WebSocket no handshake para evitar close `Error while decoding payload` no Gateway do Discord.
+- Remove o empacotamento separado `onyxcord-webhooks`; webhooks continuam incluidos diretamente na gem `onyxcord`.
+
+## 2.0.6 - 2026-06-28
+
+### Correcoes de empacotamento
+
+- Incluidos na gem os arquivos da infraestrutura async que ficaram fora do pacote `2.0.5`: `onyxcord/async/runtime` e `onyxcord/rate_limiter/async_rest`.
+- Incluidos na gem os arquivos da DSL moderna de application commands: `onyxcord/application_commands` e seus componentes internos.
+- Corrige `LoadError: cannot load such file -- onyxcord/async/runtime` ao usar a gem publicada.
+
 ## 2.0.5 - 2026-06-28
 
 ### Async Runtime (Infraestrutura nao-bloqueante)
@@ -56,7 +72,7 @@ bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
 - **Gateway via Async-WebSocket**: Substituída a implementação de raw TCP sockets + `websocket-client-simple` por `async-websocket`, proporcionando um event loop de gateway extremamente rápido e escalável.
 - **Parse JSON via Oj**: A gem `oj` foi integrada em modo de compatibilidade (`mode: :compat`), acelerando transparentemente todas as serializações e deserializações de pacotes do Discord na lib inteira.
 - **Cache Inteligente LRU**: Os caches em memória (usuários, canais, servidores, membros) agora utilizam `LruRedux::ThreadSafeCache`. Os tamanhos padrão foram aumentados (`users: 50_000`, `channels: 10_000`, `servers: 1_000`, `members: 100_000`) e podem ser customizados via `OnyxCord.configure { |c| c.cache_sizes.users = 100_000 }`.
-- **Fusão do Webhooks**: A funcionalidade da gem separada `onyxcord-webhooks` foi integrada diretamente no núcleo da gem `onyxcord`. A gem `onyxcord-webhooks` agora atua apenas como um shim de transição deprecado.
+- **Fusão do Webhooks**: A funcionalidade da gem separada `onyxcord-webhooks` foi integrada diretamente no núcleo da gem `onyxcord`; nao ha mais pacote separado para publicar.
 - **Alvo Ruby ≥ 3.4**: Atualizada a versão mínima requerida do Ruby para aproveitar as otimizações modernas do interpretador e fibras.
 
 ## 1.1.8 - 2026-06-28
@@ -73,7 +89,6 @@ bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
 - `ruby -c lib/onyxcord/data/component.rb`: sucesso.
 - `ruby -c spec/components_v2_spec.rb`: sucesso.
 - `gem build onyxcord.gemspec`: sucesso.
-- `gem build onyxcord-webhooks.gemspec`: sucesso.
 
 ## 1.1.7 - 2026-06-28
 
@@ -85,7 +100,6 @@ bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
 ### Validacao
 
 - `ruby -c onyxcord.gemspec`: sucesso.
-- `ruby -c onyxcord-webhooks.gemspec`: sucesso.
 
 ## 1.1.6 - 2026-06-28
 

data/Rakefile

@@ -6,12 +6,8 @@ namespace :main do
   Bundler::GemHelper.install_tasks(name: 'onyxcord')
 end
 
-namespace :webhooks do
-  Bundler::GemHelper.install_tasks(name: 'onyxcord-webhooks')
-end
-
-task build: %i[main:build webhooks:build]
-task release: %i[main:release webhooks:release]
+task build: :'main:build'
+task release: :'main:release'
 
 # Make "build" the default task
 task default: :build

data/lib/onyxcord/application_commands/command.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Command
+      attr_reader :name, :description, :type, :attributes, :options, :block
+
+      TYPES = {
+        chat_input: 1,
+        user: 2,
+        message: 3
+      }.freeze
+
+      def self.chat_input(name, description:, **attributes, &block)
+        new(name, description: description, type: :chat_input, **attributes, &block)
+      end
+
+      def self.user(name, **attributes, &block)
+        new(name, description: '', type: :user, **attributes, &block)
+      end
+
+      def self.message(name, **attributes, &block)
+        new(name, description: '', type: :message, **attributes, &block)
+      end
+
+      def initialize(name, description: '', type: :chat_input, **attributes, &block)
+        @name = name.to_s
+        @description = description
+        @type = type
+        @attributes = attributes
+        @options = []
+        @block = block
+        @executor = nil
+        @default_member_permissions = attributes[:default_member_permissions]
+        @nsfw = attributes[:nsfw]
+        @contexts = attributes[:contexts]
+      end
+
+      def parse(&block)
+        instance_eval(&block) if block
+        self
+      end
+
+      def execute(&block)
+        @executor = block
+      end
+
+      def call(context)
+        return unless @executor
+
+        @executor.call(context)
+      end
+
+      def to_h
+        data = {
+          name: @name,
+          type: TYPES[@type] || @type
+        }
+
+        data[:description] = @description if @type == :chat_input
+        data[:options] = @options.map(&:to_h) unless @options.empty?
+        data[:default_member_permissions] = @default_member_permissions if @default_member_permissions
+        data[:nsfw] = @nsfw if @nsfw
+        data[:contexts] = @contexts if @contexts
+
+        data
+      end
+
+      Option::OPTION_METHODS.each do |method_name, option_type|
+        define_method(method_name) do |name, description = '', **attrs, &blk|
+          opt = Option.new(name, description, option_type, **attrs, &blk)
+          @options << opt
+          opt
+        end
+      end
+
+      def subcommand(name, description, &block)
+        sub = Option.new(name, description, :subcommand, &block)
+        @options << sub
+        sub
+      end
+
+      def subcommand_group(name, description, &block)
+        group = Option.new(name, description, :subcommand_group, &block)
+        @options << group
+        group
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        if @block && @block.arity.positive?
+          @block.call(Context::Proxy.new(self, method_name, args, kwargs, block))
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands/context.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Context
+      attr_reader :event, :command
+
+      def initialize(event, command)
+        @event = event
+        @command = command
+      end
+
+      def bot
+        event.bot
+      end
+
+      def user
+        event.user
+      end
+
+      def member
+        event.user
+      end
+
+      def guild
+        event.server
+      end
+
+      def guild_id
+        event.server_id
+      end
+
+      def channel
+        event.channel
+      end
+
+      def channel_id
+        event.channel_id
+      end
+
+      def server
+        event.server
+      end
+
+      def server_id
+        event.server_id
+      end
+
+      def options
+        return {} unless event.data
+
+        if event.data['options']
+          result = {}
+          event.data['options'].each do |opt|
+            key = opt['name'].to_sym
+            result[key] = opt['value']
+          end
+          result
+        else
+          {}
+        end
+      end
+
+      def respond(...)
+        event.respond(...)
+      end
+
+      def defer(...)
+        event.defer(...)
+      end
+
+      def edit_original(...)
+        event.edit_response(...)
+      end
+
+      def delete_original
+        event.delete_response
+      end
+
+      def followup(...)
+        event.send_message(...)
+      end
+
+      class Proxy
+        def initialize(command, method_name, args, kwargs, block)
+          @command = command
+          @method_name = method_name
+          @args = args
+          @kwargs = kwargs
+          @block = block
+        end
+
+        def to_h
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands/option.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Option
+      attr_reader :name, :description, :type, :attributes, :options
+
+      OPTION_TYPES = {
+        subcommand: 1,
+        subcommand_group: 2,
+        string: 3,
+        integer: 4,
+        boolean: 5,
+        user: 6,
+        channel: 7,
+        role: 8,
+        mentionable: 9,
+        number: 10,
+        attachment: 11
+      }.freeze
+
+      OPTION_METHODS = OPTION_TYPES.each_with_object({}) do |(name, value), hash|
+        next if %i[subcommand subcommand_group].include?(name)
+
+        hash[name] = value
+      end.freeze
+
+      def initialize(name, description, type, **attributes, &block)
+        @name = name.to_s
+        @description = description
+        @type = type
+        @attributes = attributes
+        @options = []
+        @block = block
+
+        instance_eval(&@block) if @block && type == :subcommand
+      end
+
+      def to_h
+        data = {
+          name: @name,
+          description: @description,
+          type: OPTION_TYPES[@type] || @type
+        }
+
+        data[:required] = @attributes[:required] unless @attributes[:required].nil?
+        data[:min_length] = @attributes[:min_length] if @attributes[:min_length]
+        data[:max_length] = @attributes[:max_length] if @attributes[:max_length]
+        data[:min_value] = @attributes[:min_value] if @attributes[:min_value]
+        data[:max_value] = @attributes[:max_value] if @attributes[:max_value]
+        data[:autocomplete] = @attributes[:autocomplete] unless @attributes[:autocomplete].nil?
+        data[:channel_types] = @attributes[:channel_types] if @attributes[:channel_types]
+
+        if @attributes[:choices]
+          data[:choices] = @attributes[:choices].map do |name, value|
+            { name: name.to_s, value: value }
+          end
+        end
+
+        data[:options] = @options.map(&:to_h) unless @options.empty?
+
+        data
+      end
+
+      def subcommand(name, description, **attrs, &block)
+        sub = Option.new(name, description, :subcommand, **attrs, &block)
+        @options << sub
+        sub
+      end
+
+      OPTION_METHODS.each do |method_name, option_type|
+        define_method(method_name) do |name, description = '', **attrs, &blk|
+          opt = Option.new(name, description, option_type, **attrs, &blk)
+          @options << opt
+          opt
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands/registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module ApplicationCommands
+    class Registry
+      attr_reader :bot, :commands
+
+      def initialize(bot)
+        @bot = bot
+        @commands = {}
+      end
+
+      def slash(name, description:, **attributes, &block)
+        register(Command.chat_input(name, description: description, **attributes, &block))
+      end
+
+      def user(name, **attributes, &block)
+        register(Command.user(name, **attributes, &block))
+      end
+
+      def message(name, **attributes, &block)
+        register(Command.message(name, **attributes, &block))
+      end
+
+      def register(command)
+        @commands[command.name] = command
+        wire_handler(command)
+        command
+      end
+
+      def sync!(server_id: nil, delete_unknown: false)
+        payload = @commands.values.map(&:to_h)
+
+        if server_id
+          @bot.bulk_overwrite_guild_application_commands(server_id, payload)
+        else
+          @bot.bulk_overwrite_global_application_commands(payload)
+        end
+      end
+
+      private
+
+      def wire_handler(command)
+        @bot.application_command(command.name) do |event|
+          command.call(Context.new(event, command))
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/application_commands.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'onyxcord/application_commands/option'
+require 'onyxcord/application_commands/command'
+require 'onyxcord/application_commands/context'
+require 'onyxcord/application_commands/registry'
+
+module OnyxCord
+  module ApplicationCommands
+  end
+end

data/lib/onyxcord/async/runtime.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'async'
+
+module OnyxCord
+  module AsyncRuntime
+    module_function
+
+    def run(&block)
+      current = Async::Task.current?
+      return yield current if current
+
+      Async(&block).wait
+    end
+
+    def async(&block)
+      current = Async::Task.current?
+      return current.async(&block) if current
+
+      Async(&block)
+    end
+
+    def sleep(duration)
+      task = Async::Task.current?
+      return task.sleep(duration) if task.respond_to?(:sleep)
+
+      Kernel.sleep(duration)
+    end
+  end
+end

data/lib/onyxcord/gateway.rb

@@ -2,6 +2,7 @@
 
 require 'async'
 require 'async/http/endpoint'
+require 'async/http/protocol/http11'
 require 'async/websocket/client'
 require 'onyxcord/async/runtime'
 require 'onyxcord/rate_limiter/gateway'
@@ -293,9 +294,9 @@ module OnyxCord
       @pipe_broken = false
       @closed = false
 
-      endpoint = Async::HTTP::Endpoint.parse(url)
+      endpoint = websocket_endpoint(url)
 
-      Async::WebSocket::Client.connect(endpoint) do |connection|
+      Async::WebSocket::Client.connect(endpoint, extensions: nil) do |connection|
         @connection = connection
         LOGGER.debug('WebSocket connected')
 
@@ -313,6 +314,14 @@ module OnyxCord
       @connection = nil
     end
 
+    def websocket_endpoint(url)
+      Async::HTTP::Endpoint.parse(
+        url,
+        protocol: Async::HTTP::Protocol::HTTP11,
+        alpn_protocols: ['http/1.1']
+      )
+    end
+
     def handle_open; end
 
     def handle_error(e)
@@ -453,7 +462,7 @@ module OnyxCord
 
       @send_limiter.wait
 
-      @connection.write(Protocol::WebSocket::TextMessage.generate(data))
+      @connection.write(data)
       @connection.flush
     rescue StandardError => e
       @pipe_broken = true

data/lib/onyxcord/rate_limiter/async_rest.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'onyxcord/async/runtime'
+
+module OnyxCord
+  module RateLimiter
+    class AsyncRest
+      DEFAULT_ENTRY_TTL = 3600
+      DEFAULT_PRUNE_INTERVAL = 100
+
+      def initialize(clock: -> { Time.now }, entry_ttl: DEFAULT_ENTRY_TTL, prune_interval: DEFAULT_PRUNE_INTERVAL)
+        @route_buckets = {}
+        @bucket_locks = {}
+        @bucket_last_used = {}
+        @global_lock = Mutex.new
+        @clock = clock
+        @entry_ttl = entry_ttl
+        @prune_interval = prune_interval
+        @requests_since_prune = 0
+      end
+
+      def before_request(route, major_parameter)
+        wait_for(mutex_for(route, major_parameter))
+      end
+
+      def record_response(route, major_parameter, headers)
+        headers = normalize_headers(headers)
+        bucket = headers[:x_ratelimit_bucket]
+        key = route_key(route, major_parameter)
+        touch(key)
+
+        if bucket
+          bucket = bucket_key(bucket, major_parameter)
+          @route_buckets[key] = bucket
+          touch(bucket)
+        end
+
+        return unless headers[:x_ratelimit_remaining] == '0'
+
+        wait_seconds = headers[:x_ratelimit_reset_after].to_f
+        return unless wait_seconds.positive?
+
+        async_wait(wait_seconds, mutex_for(route, major_parameter))
+      end
+
+      def handle_rate_limit(route, major_parameter, response)
+        headers = normalize_headers(response.headers)
+        wait_seconds = retry_after(response, headers)
+
+        return unless wait_seconds.positive?
+
+        if headers[:x_ratelimit_global] == 'true' || headers[:x_ratelimit_scope] == 'global'
+          global_wait(wait_seconds)
+        else
+          async_wait(wait_seconds, mutex_for(route, major_parameter))
+        end
+      end
+
+      def stats
+        {
+          route_buckets: @route_buckets.size,
+          bucket_locks: @bucket_locks.size,
+          tracked_keys: @bucket_last_used.size
+        }
+      end
+
+      def prune!
+        return 0 unless @entry_ttl
+
+        cutoff = @clock.call - @entry_ttl
+        stale_keys = @bucket_last_used.select { |_, last_used| last_used < cutoff }.keys
+
+        stale_keys.each do |key|
+          @bucket_locks.delete(key)
+          @bucket_last_used.delete(key)
+          @route_buckets.delete(key)
+          @route_buckets.delete_if { |_, bucket_key| bucket_key == key }
+        end
+
+        @requests_since_prune = 0
+        stale_keys.length
+      end
+
+      private
+
+      def mutex_for(route, major_parameter)
+        key = resolved_key(route, major_parameter)
+        touch(key)
+        @bucket_locks[key] ||= Mutex.new
+      end
+
+      def resolved_key(route, major_parameter)
+        @route_buckets[route_key(route, major_parameter)] || route_key(route, major_parameter)
+      end
+
+      def route_key(route, major_parameter)
+        [route, major_parameter].freeze
+      end
+
+      def bucket_key(bucket, major_parameter)
+        [:bucket, bucket, major_parameter].freeze
+      end
+
+      def retry_after(response, headers)
+        body = response.respond_to?(:body) ? response.body : response.to_s
+        if body && !body.empty?
+          data = JSON.parse(body)
+          return data['retry_after'].to_f if data['retry_after']
+        end
+
+        (headers[:retry_after] || 0).to_f
+      rescue JSON::ParserError
+        (headers[:retry_after] || 0).to_f
+      end
+
+      def normalize_headers(headers)
+        headers.each_with_object({}) do |(key, value), memo|
+          memo[key.to_s.tr('-', '_').downcase.to_sym] = value.to_s
+        end
+      end
+
+      def touch(key)
+        @bucket_last_used[key] = @clock.call
+        prune_if_needed
+      end
+
+      def prune_if_needed
+        return unless @prune_interval
+
+        @requests_since_prune += 1
+        prune! if @requests_since_prune >= @prune_interval
+      end
+
+      def wait_for(mutex)
+        mutex.lock
+        mutex.unlock
+      end
+
+      def async_wait(time, mutex)
+        mutex.synchronize { OnyxCord::AsyncRuntime.sleep(time) }
+      end
+
+      def global_wait(time)
+        OnyxCord::AsyncRuntime.sleep(time)
+      end
+    end
+  end
+end

data/lib/onyxcord/version.rb

@@ -3,5 +3,5 @@
 # OnyxCord and all its functionality, in this case only the version.
 module OnyxCord
   # The current version of onyxcord.
-  VERSION = '2.0.5'
+  VERSION = '2.0.8'
 end

data/lib/onyxcord/webhooks/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-# Webhook support for onyxcord
+# Webhook support bundled in onyxcord.
 module OnyxCord
   module Webhooks
-    # The current version of onyxcord-webhooks.
-    VERSION = '2.0.0'
+    # Kept for compatibility with code that checks the webhooks module version.
+    VERSION = '2.0.8'
   end
 end

data/lib/onyxcord/websocket.rb

@@ -2,6 +2,7 @@
 
 require 'onyxcord/async/runtime'
 require 'async/http/endpoint'
+require 'async/http/protocol/http11'
 require 'async/websocket/client'
 
 module OnyxCord
@@ -43,10 +44,10 @@ module OnyxCord
     private
 
     def connect
-      endpoint = Async::HTTP::Endpoint.parse(@host)
+      endpoint = websocket_endpoint(@host)
 
       @task = OnyxCord::AsyncRuntime.async do
-        Async::WebSocket::Client.connect(endpoint) do |connection|
+        Async::WebSocket::Client.connect(endpoint, extensions: nil) do |connection|
           @connection = connection
           @connected = true
           @open_handler&.call
@@ -64,5 +65,13 @@ module OnyxCord
     rescue StandardError => e
       @error_handler&.call(e)
     end
+
+    def websocket_endpoint(url)
+      Async::HTTP::Endpoint.parse(
+        url,
+        protocol: Async::HTTP::Protocol::HTTP11,
+        alpn_protocols: ['http/1.1']
+      )
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onyxcord
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.8
 platform: ruby
 authors:
 - Gustavo Silva
@@ -396,6 +396,12 @@ files:
 - lib/onyxcord/api/server.rb
 - lib/onyxcord/api/user.rb
 - lib/onyxcord/api/webhook.rb
+- lib/onyxcord/application_commands.rb
+- lib/onyxcord/application_commands/command.rb
+- lib/onyxcord/application_commands/context.rb
+- lib/onyxcord/application_commands/option.rb
+- lib/onyxcord/application_commands/registry.rb
+- lib/onyxcord/async/runtime.rb
 - lib/onyxcord/await.rb
 - lib/onyxcord/bot.rb
 - lib/onyxcord/cache.rb
@@ -482,6 +488,7 @@ files:
 - lib/onyxcord/message_components.rb
 - lib/onyxcord/paginator.rb
 - lib/onyxcord/permissions.rb
+- lib/onyxcord/rate_limiter/async_rest.rb
 - lib/onyxcord/rate_limiter/gateway.rb
 - lib/onyxcord/rate_limiter/rest.rb
 - lib/onyxcord/version.rb
@@ -499,7 +506,6 @@ files:
 - lib/onyxcord/webhooks/version.rb
 - lib/onyxcord/webhooks/view.rb
 - lib/onyxcord/websocket.rb
-- onyxcord-webhooks.gemspec
 - onyxcord.gemspec
 homepage: https://github.com/kruldevb/OnyxCord
 licenses:

data/onyxcord-webhooks.gemspec

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/onyxcord/webhooks/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'onyxcord-webhooks'
-  spec.version       = OnyxCord::Webhooks::VERSION
-  spec.authors       = ['Gustavo Silva']
-  spec.email         = ['gustavosilva8kt@gmail.com']
-
-  spec.summary       = '[DEPRECATED] Webhook client for onyxcord — now bundled into the onyxcord gem'
-  spec.description   = "This gem is deprecated. Webhooks are now included in the onyxcord gem. Install 'onyxcord' instead."
-  spec.homepage      = 'https://github.com/kruldevb/OnyxCord'
-  spec.license       = 'MIT'
-
-  spec.files         = ['lib/onyxcord/webhooks.rb', 'lib/onyxcord/webhooks/version.rb']
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  # This gem now simply depends on the main onyxcord gem
-  spec.add_dependency 'onyxcord', "~> #{OnyxCord::Webhooks::VERSION}"
-
-  spec.required_ruby_version = '>= 3.4'
-  spec.metadata = {
-    'bug_tracker_uri' => 'https://github.com/kruldevb/OnyxCord/issues',
-    'documentation_uri' => 'https://github.com/kruldevb/OnyxCord#readme',
-    'source_code_uri' => 'https://github.com/kruldevb/OnyxCord',
-    'rubygems_mfa_required' => 'true'
-  }
-
-  spec.post_install_message = <<~MSG
-    ⚠️  onyxcord-webhooks is DEPRECATED.
-    Webhooks are now bundled into the 'onyxcord' gem.
-    Please update your Gemfile:
-      gem 'onyxcord', '~> 2.0'
-    and remove 'onyxcord-webhooks'.
-  MSG
-end