gruubY 0.2.0

data/lib/grubY/keyboard.rb

@@ -0,0 +1,49 @@
+module GrubY
+  class Keyboard
+    class << self
+      def inline(rows)
+        { inline_keyboard: rows }
+      end
+
+      def reply(rows, resize_keyboard: true, one_time_keyboard: false, is_persistent: false)
+        {
+          keyboard: rows,
+          resize_keyboard: resize_keyboard,
+          one_time_keyboard: one_time_keyboard,
+          is_persistent: is_persistent
+        }
+      end
+
+      def button(text, data = nil)
+        {
+          text: text.to_s,
+          callback_data: data.to_s
+        }
+      end
+
+      def url_button(text, url)
+        {
+          text: text.to_s,
+          url: url.to_s
+        }
+      end
+
+      def web_app_button(text, url)
+        {
+          text: text.to_s,
+          web_app: {
+            url: url.to_s
+          }
+        }
+      end
+
+      def switch_inline_button(text, query:, in_current_chat: false)
+        key = in_current_chat ? :switch_inline_query_current_chat : :switch_inline_query
+        {
+          text: text.to_s,
+          key => query.to_s
+        }
+      end
+    end
+  end
+end

data/lib/grubY/media.rb

@@ -0,0 +1,38 @@
+require "net/http"
+
+module GrubY
+  class Media
+    def initialize(token)
+      @base = "https://api.telegram.org/bot#{token}/"
+    end
+
+    def send_photo(chat_id, file)
+      post_file("sendPhoto", "photo", chat_id, file)
+    end
+
+    def send_video(chat_id, file)
+      post_file("sendVideo", "video", chat_id, file)
+    end
+
+    def send_audio(chat_id, file)
+      post_file("sendAudio", "audio", chat_id, file)
+    end
+
+    def post_file(method, field_name, chat_id, file)
+      uri = URI(@base + method)
+
+      File.open(file, "rb") do |io|
+        req = Net::HTTP::Post.new(uri)
+        form_data = [
+          ["chat_id", chat_id],
+          [field_name, io]
+        ]
+
+        req.set_form form_data, "multipart/form-data"
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+      end
+    end
+  end
+end

data/lib/grubY/middleware.rb

@@ -0,0 +1,18 @@
+module GrubY
+  class Middleware
+    def initialize
+      @stack = []
+    end
+
+    def use(&block)
+      @stack << block
+    end
+
+    def run(ctx, &final)
+      chain = @stack.reverse.inject(final) do |nxt, mw|
+        proc { mw.call(ctx, nxt) }
+      end
+      chain.call
+    end
+  end
+end

data/lib/grubY/ntgcalls/native.rb

@@ -0,0 +1,100 @@
+require "ffi"
+
+module GrubY
+  module NTgCalls
+    module Native
+      extend FFI::Library
+
+      class LibraryNotFoundError < StandardError; end
+
+      callback :ntg_async_callback, [:pointer], :void
+
+      class NtgAsyncStruct < FFI::Struct
+        layout :userData, :pointer,
+               :errorCode, :pointer,
+               :errorMessage, :pointer,
+               :promise, :ntg_async_callback
+      end
+
+      class NtgAudioDescriptionStruct < FFI::Struct
+        layout :mediaSource, :int,
+               :input, :string,
+               :sampleRate, :uint32,
+               :channelCount, :uint8,
+               :keepOpen, :bool
+      end
+
+      class NtgMediaDescriptionStruct < FFI::Struct
+        layout :microphone, :pointer,
+               :speaker, :pointer,
+               :camera, :pointer,
+               :screen, :pointer
+      end
+
+      class << self
+        def load!(path = nil)
+          return if @loaded
+
+          ffi_lib(resolve_library_path(path))
+          attach_function :ntg_init, [], :uintptr_t
+          attach_function :ntg_destroy, [:uintptr_t], :int
+          attach_function :ntg_get_version, [:pointer], :int
+          attach_function :ntg_create, [:uintptr_t, :int64, :pointer, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_connect, [:uintptr_t, :int64, :string, :bool, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_set_stream_sources, [:uintptr_t, :int64, :int, NtgMediaDescriptionStruct.by_value, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_pause, [:uintptr_t, :int64, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_resume, [:uintptr_t, :int64, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_mute, [:uintptr_t, :int64, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_unmute, [:uintptr_t, :int64, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_stop, [:uintptr_t, :int64, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_time, [:uintptr_t, :int64, :int, :pointer, NtgAsyncStruct.by_value], :int
+          attach_function :ntg_cpu_usage, [:uintptr_t, :pointer, NtgAsyncStruct.by_value], :int
+          @loaded = true
+        end
+
+        private
+
+        def resolve_library_path(custom_path)
+          return custom_path if custom_path && File.exist?(custom_path)
+
+          env_path = ENV["NTGCALLS_PATH"]
+          return env_path if env_path && File.exist?(env_path)
+
+          found = default_candidates.find { |path| File.exist?(path) }
+          return found if found
+
+          raise LibraryNotFoundError,
+            "NTgCalls shared library not found. Set NTGCALLS_PATH or pass lib_path."
+        end
+
+        def default_candidates
+          if Gem.win_platform?
+            [
+              "ntgcalls.dll",
+              "vendor/ntgcalls/windows/ntgcalls.dll",
+              "vendor/ntgcalls/ntgcalls.dll",
+              "C:/ntgcalls/bin/ntgcalls.dll"
+            ]
+          elsif RUBY_PLATFORM.include?("darwin")
+            [
+              "libntgcalls.dylib",
+              "vendor/ntgcalls/macos/libntgcalls.dylib",
+              "vendor/ntgcalls/darwin/libntgcalls.dylib",
+              "vendor/ntgcalls/libntgcalls.dylib",
+              "/usr/local/lib/libntgcalls.dylib",
+              "/opt/homebrew/lib/libntgcalls.dylib"
+            ]
+          else
+            [
+              "libntgcalls.so",
+              "vendor/ntgcalls/linux/libntgcalls.so",
+              "vendor/ntgcalls/libntgcalls.so",
+              "/usr/lib/libntgcalls.so",
+              "/usr/local/lib/libntgcalls.so"
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grubY/ntgcalls.rb

@@ -0,0 +1,478 @@
+require "timeout"
+require "thread"
+require "securerandom"
+require_relative "ntgcalls/native"
+require_relative "raw"
+require_relative "tdlib/client"
+require_relative "tdlib/user_session"
+require_relative "raw_types"
+
+module GrubY
+  module NTgCalls
+    class Error < StandardError; end
+
+    module StreamMode
+      CAPTURE = 0
+      PLAYBACK = 1
+    end
+
+    module MediaSource
+      FILE = 1 << 0
+      SHELL = 1 << 1
+      FFMPEG = 1 << 2
+      DEVICE = 1 << 3
+      DESKTOP = 1 << 4
+      EXTERNAL = 1 << 5
+    end
+
+    class Client
+      DEFAULT_TIMEOUT = 20
+      attr_reader :handle
+
+      def initialize(lib_path: nil)
+        Native.load!(lib_path)
+        @handle = Native.ntg_init
+        raise Error, "ntgcalls init failed" if @handle.nil? || @handle.zero?
+      end
+
+      def self.version(lib_path: nil)
+        Native.load!(lib_path)
+        version_ptr = FFI::MemoryPointer.new(:pointer)
+        code = Native.ntg_get_version(version_ptr)
+        raise Error, "ntg_get_version failed with code=#{code}" if code.negative?
+
+        read_c_string_ptr(version_ptr)
+      end
+
+      def close
+        return if @handle.nil? || @handle.zero?
+
+        code = Native.ntg_destroy(@handle)
+        raise Error, "ntg_destroy failed with code=#{code}" if code.negative?
+
+        @handle = nil
+      end
+
+      alias stop close
+
+      def create(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async_string(:ntg_create, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def connect(chat_id:, params:, is_presentation: false, timeout: DEFAULT_TIMEOUT)
+        call_async(
+          :ntg_connect,
+          [handle!, chat_id.to_i, params.to_s, !!is_presentation],
+          timeout: timeout
+        )
+      end
+
+      def play(chat_id:, stream:, sample_rate: 48_000, channels: 2, keep_open: false, timeout: DEFAULT_TIMEOUT)
+        audio = Native::NtgAudioDescriptionStruct.new
+        audio[:mediaSource] = MediaSource::FILE
+        audio[:input] = stream.to_s
+        audio[:sampleRate] = sample_rate.to_i
+        audio[:channelCount] = channels.to_i
+        audio[:keepOpen] = !!keep_open
+
+        media = Native::NtgMediaDescriptionStruct.new
+        media[:microphone] = audio.to_ptr
+        media[:speaker] = FFI::Pointer::NULL
+        media[:camera] = FFI::Pointer::NULL
+        media[:screen] = FFI::Pointer::NULL
+
+        call_async(
+          :ntg_set_stream_sources,
+          [handle!, chat_id.to_i, StreamMode::CAPTURE, media],
+          timeout: timeout
+        )
+      end
+
+      def pause(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async(:ntg_pause, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def resume(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async(:ntg_resume, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def mute(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async(:ntg_mute, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def unmute(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async(:ntg_unmute, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def stop_call(chat_id:, timeout: DEFAULT_TIMEOUT)
+        call_async(:ntg_stop, [handle!, chat_id.to_i], timeout: timeout)
+      end
+
+      def cpu_usage(timeout: DEFAULT_TIMEOUT)
+        out = FFI::MemoryPointer.new(:double)
+        call_async(:ntg_cpu_usage, [handle!, out], timeout: timeout)
+        out.read_double
+      end
+
+      def time(chat_id:, mode: StreamMode::CAPTURE, timeout: DEFAULT_TIMEOUT)
+        out = FFI::MemoryPointer.new(:int64)
+        call_async(:ntg_time, [handle!, chat_id.to_i, mode.to_i, out], timeout: timeout)
+        out.read_int64
+      end
+
+      private
+
+      def handle!
+        raise Error, "ntgcalls client is closed" if @handle.nil? || @handle.zero?
+
+        @handle
+      end
+
+      def call_async_string(function_name, args, timeout:)
+        out_ptr = FFI::MemoryPointer.new(:pointer)
+        call_async(function_name, args + [out_ptr], timeout: timeout)
+        self.class.read_c_string_ptr(out_ptr)
+      end
+
+      def call_async(function_name, args, timeout:)
+        done = Queue.new
+        error_code = FFI::MemoryPointer.new(:int)
+        error_code.write_int(0)
+        error_message = FFI::MemoryPointer.new(:pointer)
+        error_message.write_pointer(FFI::Pointer::NULL)
+
+        callback = proc do |_user_data|
+          done << true
+        end
+
+        future = Native::NtgAsyncStruct.new
+        future[:userData] = FFI::Pointer::NULL
+        future[:errorCode] = error_code
+        future[:errorMessage] = error_message
+        future[:promise] = callback
+
+        code = Native.public_send(function_name, *args, future)
+        raise_native_error(code, error_message) if code.negative?
+
+        begin
+          Timeout.timeout(timeout) { done.pop }
+        rescue Timeout::Error
+          raise Error, "ntgcalls timeout while waiting for #{function_name}"
+        end
+
+        async_code = error_code.read_int
+        raise_native_error(async_code, error_message) if async_code.negative?
+        true
+      end
+
+      def raise_native_error(code, error_message_ptr)
+        message_ptr = error_message_ptr.read_pointer
+        native_message = message_ptr.null? ? nil : message_ptr.read_string
+        suffix = native_message.to_s.empty? ? "" : " (#{native_message})"
+        raise Error, "ntgcalls error code=#{code}#{suffix}"
+      end
+
+      class << self
+        def read_c_string_ptr(pointer_to_pointer)
+          ptr = pointer_to_pointer.read_pointer
+          return "" if ptr.null?
+
+          ptr.read_string
+        end
+      end
+    end
+
+    class MusicBot
+      DEFAULT_AUTH_TIMEOUT = 180
+
+      def initialize(
+        td_user_session:,
+        tdjson_path: nil,
+        ntgcalls_path: nil,
+        phone_number: nil,
+        td_verbosity: 1
+      )
+        td_cfg = GrubY::TDLib::UserSession.client_kwargs(td_user_session)
+        @td = GrubY::TDLib::Client.new(
+          **td_cfg,
+          phone_number: phone_number,
+          tdjson_path: tdjson_path,
+          td_verbosity: td_verbosity,
+          workers: 2
+        )
+        @ntg = Client.new(lib_path: ntgcalls_path)
+        @joined_chat_id = nil
+        @phone_number = phone_number
+        @td.on("updateAuthorizationState") { |update| handle_auth_state(update) }
+      end
+
+      def start(timeout: DEFAULT_AUTH_TIMEOUT)
+        @td.start
+        wait_until_authorized!(timeout: timeout)
+        self
+      end
+
+      def stop
+        @ntg.close
+        @td.stop
+      end
+
+      def join_and_play(chat:, audio:, invite_hash: "")
+        chat_id = resolve_chat_id(chat)
+        input_group_call = fetch_input_group_call(chat_id)
+        local_offer = @ntg.create(chat_id: chat_id)
+        audio_source_id = deterministic_audio_source_id(chat_id)
+
+        join_response = try_join_group_call(
+          input_group_call: input_group_call,
+          local_offer: local_offer,
+          audio_source_id: audio_source_id,
+          invite_hash: invite_hash
+        )
+        remote_params = extract_join_payload(join_response)
+        raise Error, "joinGroupCall response did not contain tgcalls params" if remote_params.to_s.empty?
+
+        @ntg.connect(chat_id: chat_id, params: remote_params)
+        @ntg.play(chat_id: chat_id, stream: audio)
+        @joined_chat_id = chat_id
+
+        {
+          chat_id: chat_id,
+          offer: local_offer,
+          remote_params: remote_params
+        }
+      end
+
+      def input_group_call(chat:)
+        chat_id = resolve_chat_id(chat)
+        fetch_input_group_call(chat_id)
+      end
+
+      def input_peer_self
+        GrubY::RawTypes.input_peer_self
+      end
+
+      def data_json(value)
+        GrubY::RawTypes.to_data_json(value)
+      end
+
+      def join_group_call(chat:, payload:, audio_source_id:, muted: false, video_stopped: true, invite_hash: nil)
+        call = input_group_call(chat: chat)
+        params = data_json(payload)
+        query = GrubY::RawTypes.join_group_call(
+          call: call,
+          params: params,
+          muted: muted,
+          video_stopped: video_stopped,
+          invite_hash: invite_hash,
+          join_as: input_peer_self
+        )
+        GrubY::Raw.td_call!(@td, mtproto_to_td_join_query(query, audio_source_id: audio_source_id))
+      end
+
+      def leave_group_call(chat:, source:)
+        call = input_group_call(chat: chat)
+        query = GrubY::RawTypes.leave_group_call(call: call, source: source)
+        GrubY::Raw.td_call!(@td, mtproto_to_td_leave_query(query))
+      end
+
+      def update_group_call(payload)
+        GrubY::RawTypes.update_group_call(payload)
+      end
+
+      def pause
+        @ntg.pause(chat_id: joined_chat_id!)
+      end
+
+      def resume
+        @ntg.resume(chat_id: joined_chat_id!)
+      end
+
+      def mute
+        @ntg.mute(chat_id: joined_chat_id!)
+      end
+
+      def unmute
+        @ntg.unmute(chat_id: joined_chat_id!)
+      end
+
+      def stop_call
+        @ntg.stop_call(chat_id: joined_chat_id!)
+      end
+
+      def cpu_usage
+        @ntg.cpu_usage
+      end
+
+      def time
+        @ntg.time(chat_id: joined_chat_id!)
+      end
+
+      private
+
+      def joined_chat_id!
+        raise Error, "no active group call in this bot instance" if @joined_chat_id.nil?
+
+        @joined_chat_id
+      end
+
+      def wait_until_authorized!(timeout:)
+        deadline = Time.now + timeout
+        loop do
+          return true if @td.authorized?
+          raise Error, "TDLib authorization timeout" if Time.now > deadline
+          sleep 0.25
+        end
+      end
+
+      def handle_auth_state(update)
+        state = update.dig("authorization_state", "@type")
+        case state
+        when "authorizationStateWaitPhoneNumber"
+          phone = @phone_number.to_s.strip
+          phone = prompt("Enter phone number (+countrycode...): ") if phone.empty?
+          @td.send_query("@type": "setAuthenticationPhoneNumber", phone_number: phone)
+        when "authorizationStateWaitCode"
+          code = prompt("Enter Telegram login code: ")
+          @td.check_authentication_code(code)
+        when "authorizationStateWaitPassword"
+          password = prompt("Enter 2FA password: ")
+          @td.check_authentication_password(password)
+        when "authorizationStateWaitOtherDeviceConfirmation"
+          link = update.dig("authorization_state", "link")
+          warn "[NTgCalls] Open Telegram > Settings > Devices > Link Desktop Device"
+          warn "[NTgCalls] #{link}" if link
+        end
+      end
+
+      def prompt(label)
+        print label
+        STDIN.gets.to_s.strip
+      end
+
+      def resolve_chat_id(chat)
+        text = chat.to_s.strip
+        raise Error, "chat is required" if text.empty?
+
+        return text.to_i if text.match?(/\A-?\d+\z/)
+
+        username = text.start_with?("@") ? text : "@#{text}"
+        result = @td.raw!("@type": "searchPublicChat", username: username.delete_prefix("@"))
+        chat_id = result["id"].to_i
+        raise Error, "unable to resolve chat '#{chat}'" if chat_id.zero?
+
+        chat_id
+      end
+
+      def fetch_input_group_call(chat_id)
+        chat = @td.raw!("@type": "getChat", chat_id: chat_id)
+        video_chat = chat["video_chat"] || {}
+        group_call_id = video_chat["group_call_id"] || dig_group_call_id(video_chat)
+        raise Error, "no active voice chat found for chat_id=#{chat_id}" if group_call_id.to_i.zero?
+
+        access_hash = video_chat["group_call_access_hash"] || dig_group_call_access_hash(video_chat)
+        {
+          "@type" => "inputGroupCall",
+          "id" => group_call_id.to_i,
+          "access_hash" => access_hash.to_i
+        }
+      end
+
+      def try_join_group_call(input_group_call:, local_offer:, audio_source_id:, invite_hash:)
+        candidates = [
+          {
+            "@type": "joinGroupCall",
+            "group_call_id": input_group_call["id"],
+            "participant_id": nil,
+            "audio_source_id": audio_source_id,
+            "payload": local_offer,
+            "is_muted": false,
+            "is_my_video_enabled": false,
+            "invite_hash": invite_hash.to_s
+          },
+          {
+            "@type": "joinGroupCall",
+            "input_group_call": input_group_call,
+            "join_parameters": {
+              "@type": "groupCallJoinParameters",
+              "payload": local_offer,
+              "audio_source_id": audio_source_id,
+              "is_muted": false,
+              "is_my_video_enabled": false,
+              "invite_hash": invite_hash.to_s
+            }
+          }
+        ]
+
+        last_error = nil
+        candidates.each do |query|
+          response = @td.raw(query)
+          return response unless response.is_a?(Hash) && response["@type"] == "error"
+
+          last_error = response["message"].to_s
+        end
+        raise Error, "joinGroupCall failed: #{last_error}"
+      end
+
+      def mtproto_to_td_join_query(mtproto_query, audio_source_id:)
+        {
+          "@type": "joinGroupCall",
+          input_group_call: mtproto_query["call"],
+          join_parameters: {
+            "@type": "groupCallJoinParameters",
+            payload: mtproto_query.dig("params", "data"),
+            audio_source_id: audio_source_id.to_i,
+            is_muted: !!mtproto_query["muted"],
+            is_my_video_enabled: !mtproto_query["video_stopped"],
+            invite_hash: mtproto_query["invite_hash"].to_s
+          }
+        }
+      end
+
+      def mtproto_to_td_leave_query(mtproto_query)
+        {
+          "@type": "leaveGroupCall",
+          input_group_call: mtproto_query["call"]
+        }
+      end
+
+      def extract_join_payload(response)
+        return response["text"] if response["text"].is_a?(String)
+        return response["payload"] if response["payload"].is_a?(String)
+
+        group_call_info = response["group_call_info"] || response["groupCallInfo"] || {}
+        return group_call_info["payload"] if group_call_info["payload"].is_a?(String)
+        return group_call_info["params"] if group_call_info["params"].is_a?(String)
+
+        params = response["params"] || response["connection_params"]
+        return params if params.is_a?(String)
+
+        ""
+      end
+
+      def deterministic_audio_source_id(chat_id)
+        seed = "#{chat_id}:#{Process.pid}:#{SecureRandom.hex(4)}"
+        value = seed.each_byte.reduce(0) { |acc, b| ((acc * 131) + b) & 0x7fffffff }
+        value.zero? ? 1 : value
+      end
+
+      def dig_group_call_id(video_chat)
+        group_call = video_chat["group_call"] || {}
+        group_call["id"]
+      end
+
+      def dig_group_call_access_hash(video_chat)
+        group_call = video_chat["group_call"] || {}
+        group_call["access_hash"]
+      end
+    end
+
+    class Bridge
+      def initialize(*_args, **_kwargs)
+        raise Error, "Use GrubY::NTgCalls::Client (pure Ruby and ntgcalls C bindings)."
+      end
+    end
+
+    class RBtgCalls < Bridge; end
+  end
+end

data/lib/grubY/plugin.rb

@@ -0,0 +1,14 @@
+module GrubY
+  class Plugin
+    def self.load(bot, path)
+      mod = Module.new
+      mod.module_eval(File.read(path), path)
+
+      if mod.respond_to?(:register)
+        mod.register(bot)
+      else
+        raise "Plugin must define register(bot)"
+      end
+    end
+  end
+end