gruubY 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ef2f9709d76322e1eff6824e63ba6476cac004e5c6d47b09e0b73b64b0a090a
+  data.tar.gz: 77b279b046e9b8a760e721d5289ac6de30a7b390771e55d79b568a5197be0550
+SHA512:
+  metadata.gz: 9c88a5cda9410a8e150afee26b78e9974c38e803d4bcd7fbbd9ab03ce652a358e1cc9b05b64077f5ecca9c0f1573a4c407c2435c949ecc4ecff07f39e813283c
+  data.tar.gz: 67fd67fd3a9ffe5056d4e69a59d80e5b8e142ea455835bb96236b54692aa757bf3d11e33901913718db5fa1fa8c0673137bb6d53cd4d73c77b47503257ebd2b9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sreyanshu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+> GrubY (Unstable)
+
+[![Ruby](https://img.shields.io/badge/ruby-3.2.0-red.svg)](https://www.ruby-lang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+*Maintained by [Sreyanshu](https://github.com/iSreyanshu)*

data/Rakefile

@@ -0,0 +1,51 @@
+require "rake/clean"
+
+APP_ROOT = File.expand_path(__dir__)
+
+CLEAN.include(*Dir["*.gem"])
+
+desc "Build gem package"
+task :build do
+  sh "gem build grubY.gemspec"
+end
+
+desc "Install built gem locally"
+task install_local: :build do
+  gem_file = Dir["grubY-*.gem"].max_by { |f| File.mtime(f) }
+  abort "No gem package found" unless gem_file
+
+  sh "gem install #{gem_file}"
+end
+
+desc "Install Ruby dependencies"
+task :bundle_install do
+  sh "bundle install"
+end
+
+desc "Prepare Ruby dependencies"
+task setup: [:bundle_install]
+
+namespace :ci do
+  desc "Minimal smoke check for gem load"
+  task :smoke do
+    ruby "-e", "require_relative 'lib/grubY'; puts 'grubY load ok'"
+  end
+end
+
+namespace :tdlib do
+  desc "Generate tdlib.json in project root (override via SRC, VERSION, COMMIT, OUT env vars)"
+  task :generate_json do
+    src = ENV.fetch("SRC", "https://raw.githubusercontent.com/tdlib/td/refs/heads/master/td/generate/scheme/td_api.tl")
+    version = ENV.fetch("VERSION", "")
+    commit = ENV.fetch("COMMIT", "")
+    out = ENV.fetch("OUT", File.join(APP_ROOT, "tdlib.json"))
+
+    ruby "scripts/generate-tdlib-json.rb",
+         "--src", src,
+         "--version", version,
+         "--commit", commit,
+         "--out", out
+  end
+end
+
+task default: :build

data/config/config.rb

@@ -0,0 +1,5 @@
+module Config
+  TOKEN = "7543495331:AAHLYllkmBjf0VjKy4qxLSlA7DBA45htvdQ"
+  WEBHOOK_PATH = "/webhook"
+  PORT = 4545
+end

data/example/bot.rb

@@ -0,0 +1,160 @@
+require_relative "../lib/grubY"
+require_relative "../config/config"
+
+client = GrubY::Client.new(Config::TOKEN)
+gm = client.group_manager
+
+client.use_plugin("../plugins/logger.rb")
+
+HELP = <<~TXT
+  Commands:
+  /start - Boot check
+  /help - Show this help message
+  /echo <text> - Echo text
+  /md <text> - Markdown v2 safe send
+  /html <text> - HTML safe send
+  /poll - Send sample poll
+  /media - Send sample media methods
+  /whoami - Show user and chat info
+  /warn <user_ID> [reason] - Warn user
+  /mute <user_ID> - Mute user
+  /unmute <user_ID> - Unmute user
+  /ban <user_ID> - Ban user
+  /unban <user_ID> - Unban user
+  /pin - Pin message
+  /unpin - Unpin latest pinned message
+  /lock - Lock group
+  /unlock - Unlock group
+  /reaction - Set reaction on replied message
+TXT
+
+client.on(:message, GrubY::Filters.command("start")) do |ctx|
+  ctx.reply("GrubY Client started! Use /help for help message.")
+end
+
+client.on(:message, GrubY::Filters.command("help")) do |ctx|
+  ctx.reply(HELP)
+end
+
+client.on(:message, GrubY::Filters.command("echo")) do |ctx|
+  text = ctx.command_args.join(" ")
+  ctx.reply(text.empty? ? "Usage: /echo good morning" : text)
+end
+
+client.on(:message, GrubY::Filters.command("md")) do |ctx|
+  text = ctx.command_args.join(" ")
+  safe = GrubY::API.escape_markdown_v2(text.empty? ? "markdown_v2 demo" : text)
+  client.send_message(ctx.chat_id, "*Safe:* #{safe}", parse_mode: "MarkdownV2")
+end
+
+client.on(:message, GrubY::Filters.command("html")) do |ctx|
+  text = ctx.command_args.join(" ")
+  safe = GrubY::API.escape_html(text.empty? ? "<b>html</b> demo" : text)
+  client.send_message(ctx.chat_id, "<b>Safe:</b> #{safe}", parse_mode: "HTML")
+end
+
+client.on(:message, GrubY::Filters.command("poll")) do |ctx|
+  client.send_poll(
+    ctx.chat_id,
+    "Pick Stack",
+    [
+      { text: "Ruby" },
+      { text: "Python" },
+      { text: "JavaScript" }
+    ],
+    is_anonymous: false,
+    allows_multiple_answers: true
+  )
+end
+
+client.on(:message, GrubY::Filters.command("media")) do |ctx|
+  client.send_chat_action(ctx.chat_id, "typing")
+  ctx.reply("Try these API methods from code: send_photo/send_audio/send_document/send_video/send_animation/send_voice/send_video_note/send_media_group/send_paid_media")
+end
+
+client.on(:message, GrubY::Filters.command("whoami")) do |ctx|
+  user = ctx.user
+  chat = ctx.message&.chat
+  text = "user_id=#{user&.id} username=@#{user&.username} chat_id=#{chat&.id} chat_type=#{chat&.type}"
+  ctx.reply(text)
+end
+
+client.on(:message, GrubY::Filters.command("warn")) do |ctx|
+  user_id = ctx.command_args[0]&.to_i
+  reason = ctx.command_args[1..]&.join(" ")
+  if user_id.nil? || user_id.zero?
+    ctx.reply("Usage: /warn <user_ID> [reason]")
+    next
+  end
+
+  result = gm.enforce_warns(ctx.chat_id, user_id, reason: reason)
+  if result[:action] == :kick
+    ctx.reply("User #{user_id} has been kicked. Reason: Warning limit exceeded.")
+  else
+    ctx.reply("Warned #{user_id}. #{result[:warns]}/#{result[:limit]}")
+  end
+end
+
+client.on(:message, GrubY::Filters.command("mute")) do |ctx|
+  user_id = ctx.command_args[0]&.to_i
+  next ctx.reply("Usage: /mute <user_ID>") if user_id.nil? || user_id.zero?
+
+  gm.mute(ctx.chat_id, user_id)
+  ctx.reply("Muted #{user_id}")
+end
+
+client.on(:message, GrubY::Filters.command("unmute")) do |ctx|
+  user_id = ctx.command_args[0]&.to_i
+  next ctx.reply("Usage: /unmute <user_ID>") if user_id.nil? || user_id.zero?
+
+  gm.unmute(ctx.chat_id, user_id)
+  ctx.reply("Unmuted #{user_id}")
+end
+
+client.on(:message, GrubY::Filters.command("ban")) do |ctx|
+  user_id = ctx.command_args[0]&.to_i
+  next ctx.reply("Usage: /ban <user_ID>") if user_id.nil? || user_id.zero?
+
+  gm.ban(ctx.chat_id, user_id)
+  ctx.reply("Banned #{user_id}")
+end
+
+client.on(:message, GrubY::Filters.command("unban")) do |ctx|
+  user_id = ctx.command_args[0]&.to_i
+  next ctx.reply("Usage: /unban <user_ID>") if user_id.nil? || user_id.zero?
+
+  gm.unban(ctx.chat_id, user_id, only_if_banned: true)
+  ctx.reply("Unbanned #{user_id}")
+end
+
+client.on(:message, GrubY::Filters.command("pin")) do |ctx|
+  gm.pin(ctx.chat_id, ctx.message.message_id)
+  ctx.reply("Pinned this message.")
+end
+
+client.on(:message, GrubY::Filters.command("unpin")) do |ctx|
+  gm.unpin(ctx.chat_id)
+  ctx.reply("Unpinned latest message.")
+end
+
+client.on(:message, GrubY::Filters.command("lock")) do |ctx|
+  gm.lock(ctx.chat_id)
+  ctx.reply("Group locked!")
+end
+
+client.on(:message, GrubY::Filters.command("unlock")) do |ctx|
+  gm.unlock(ctx.chat_id)
+  ctx.reply("Group unlocked!")
+end
+
+client.on(:message, GrubY::Filters.command("reaction")) do |ctx|
+  message_id = ctx.message.message_id
+  client.send_reaction(ctx.chat_id, message_id, reaction: [{ type: "emoji", emoji: "\u{1F525}" }])
+  ctx.reply("Reaction sent.")
+end
+
+client.on(:message, GrubY::Filters.regex(/hello/i)) do |ctx|
+  ctx.reply("Hello world from GrubY!")
+end
+
+client.run

data/example/generate_user_session.rb

@@ -0,0 +1,81 @@
+require_relative "../lib/grubY"
+
+def prompt(label)
+  print label
+  STDIN.gets.to_s.strip
+end
+
+api_id = ENV["TD_API_ID"]&.to_i
+api_hash = ENV["TD_API_HASH"].to_s
+session_name = ENV.fetch("TD_SESSION_NAME", "default")
+
+abort("Missing TD_API_ID or TD_API_HASH") if api_id.nil? || api_hash.empty?
+
+bundle = GrubY::TDLib::UserSession.build(session_name: session_name)
+session_string = GrubY::TDLib::UserSession.encode(
+  api_id: api_id,
+  api_hash: api_hash,
+  database_directory: bundle[:database_directory],
+  files_directory: bundle[:files_directory],
+  database_encryption_key: bundle[:database_encryption_key],
+  session_name: bundle[:session_name]
+)
+
+client = GrubY::TDLib::Client.new(
+  api_id: api_id,
+  api_hash: api_hash,
+  database_directory: bundle[:database_directory],
+  files_directory: bundle[:files_directory],
+  database_encryption_key: bundle[:database_encryption_key],
+  tdjson_path: ENV["TDJSON_PATH"],
+  td_verbosity: 2,
+  workers: 2
+)
+
+client.on("updateAuthorizationState") do |update|
+  state = update.dig("authorization_state", "@type")
+
+  case state
+  when "authorizationStateWaitPhoneNumber"
+    loop do
+      phone = prompt("Enter phone number (+countrycode...): ")
+      next if phone.empty?
+
+      client.set_authentication_phone_number(phone_number: phone)
+      break
+    end
+  when "authorizationStateWaitCode"
+    loop do
+      code = prompt("Enter login code: ")
+      next if code.empty?
+
+      client.check_authentication_code(code)
+      break
+    end
+  when "authorizationStateWaitPassword"
+    loop do
+      pass = prompt("Enter 2FA password: ")
+      next if pass.empty?
+
+      client.check_authentication_password(pass)
+      break
+    end
+  when "authorizationStateWaitOtherDeviceConfirmation"
+    link = update.dig("authorization_state", "link")
+    puts "Open Telegram > Settings > Devices > Link Desktop Device"
+    puts link.to_s
+  when "authorizationStateReady"
+    me = client.get_me
+    puts "Authorized: #{me['first_name']} (id=#{me['id']})"
+    puts
+    puts "TD_USER_SESSION=#{session_string}"
+    puts
+    puts "Reuse in Ruby:"
+    puts "  cfg = GrubY::TDLib::UserSession.client_kwargs(ENV.fetch('TD_USER_SESSION'))"
+    puts "  client = GrubY::TDLib::Client.new(**cfg)"
+    client.stop
+  end
+end
+
+client.start
+sleep 0.3 while client.authorized? == false

data/example/ntgcalls.rb

@@ -0,0 +1,80 @@
+require_relative "../lib/grubY"
+require "json"
+
+# Usage:
+# TD_USER_SESSION='<base64>' \
+# VC_CHAT='@YourGroupOrChannel' \
+# VC_AUDIO=./song.mp3 \
+# ruby example/ntgcalls.rb
+#
+# Optional:
+# TDJSON_PATH=/path/to/libtdjson.so
+# NTGCALLS_PATH=/path/to/libntgcalls.so
+# VC_INVITE_HASH=xxxx
+
+td_user_session = ENV["TD_USER_SESSION"].to_s
+chat = ENV["VC_CHAT"].to_s
+audio = ENV["VC_AUDIO"].to_s
+
+abort("Missing TD_USER_SESSION") if td_user_session.empty?
+abort("Missing VC_CHAT (chat ID or @username)") if chat.empty?
+abort("Missing VC_AUDIO") if audio.empty?
+
+bot = GrubY::NTgCalls::MusicBot.new(
+  td_user_session: td_user_session,
+  tdjson_path: ENV["TDJSON_PATH"],
+  ntgcalls_path: ENV["NTGCALLS_PATH"],
+  phone_number: ENV["TD_PHONE"]
+)
+
+begin
+  bot.start
+  result = bot.join_and_play(
+    chat: chat,
+    audio: audio,
+    invite_hash: ENV.fetch("VC_INVITE_HASH", "")
+  )
+  puts "[NTgCalls] Joined chat #{result[:chat_id]} and started playback"
+  puts "[NTgCalls] offer payload size=#{result[:offer].to_s.bytesize}"
+
+  puts "Commands: pause, resume, mute, unmute, time, cpu, stop, showraw, quit"
+  loop do
+    print "> "
+    cmd = STDIN.gets.to_s.strip.downcase
+
+    case cmd
+    when "pause"
+      bot.pause
+      puts "paused"
+    when "resume"
+      bot.resume
+      puts "resumed"
+    when "mute"
+      bot.mute
+      puts "muted"
+    when "unmute"
+      bot.unmute
+      puts "unmuted"
+    when "time"
+      puts bot.time
+    when "cpu"
+      puts bot.cpu_usage
+    when "stop"
+      bot.stop_call
+      puts "stopped"
+    when "showraw"
+      igc = bot.input_group_call(chat: chat)
+      puts "InputGroupCall: #{igc.to_json}"
+      puts "InputPeerSelf: #{bot.input_peer_self.to_json}"
+      puts "DataJSON: #{bot.data_json(result[:offer]).to_json}"
+      puts "JoinGroupCall: #{GrubY::RawTypes.join_group_call(call: igc, params: bot.data_json(result[:offer])).to_json}"
+      puts "LeaveGroupCall: #{GrubY::RawTypes.leave_group_call(call: igc, source: 0).to_json}"
+    when "quit", "exit"
+      break
+    else
+      puts "Unknown command!"
+    end
+  end
+ensure
+  bot.stop
+end

data/example/tdlib.rb

@@ -0,0 +1,77 @@
+require_relative "../lib/grubY"
+
+# Set these in your environment before running:
+# TD_API_ID=12345
+# TD_API_HASH=xxxxx
+# TD_BOT_TOKEN=12345:abc.. (or use TD_PHONE for user auth)
+# TDJSON_PATH=/path/to/libtdjson.so|dylib|dll
+
+api_id = ENV["TD_API_ID"]&.to_i
+api_hash = ENV["TD_API_HASH"]
+bot_token = ENV["TD_BOT_TOKEN"]
+phone = ENV["TD_PHONE"]
+
+abort("Missing TD_API_ID or TD_API_HASH") unless api_id && api_hash
+
+client = GrubY::TDLib::Client.new(
+  api_id: api_id,
+  api_hash: api_hash,
+  bot_token: bot_token,
+  phone_number: phone,
+  tdjson_path: ENV["TDJSON_PATH"],
+  workers: 4,
+  default_handler_timeout: 10
+)
+
+gm = client.group_manager
+
+client.on("clientReady") do
+  puts "[TDLIB] ready"
+end
+
+client.initializer do |update|
+  type = update["@type"]
+  puts "[TDLIB] update=#{type}" if type
+end
+
+client.on("authCodeNeeded") do
+  print "Enter login code: "
+  code = STDIN.gets.to_s.strip
+  client.check_authentication_code(code)
+end
+
+client.on("authPasswordNeeded") do
+  print "Enter 2FA password: "
+  pass = STDIN.gets.to_s.strip
+  client.check_authentication_password(pass)
+end
+
+client.on_message do |message|
+  chat_id = message["chat_id"]
+  content = message.dig("content", "@type")
+
+  next unless content == "messageText"
+
+  text = message.dig("content", "text", "text").to_s
+  next unless text.start_with?("/")
+
+  case text
+  when "/ping"
+    client.sendMessage(
+      chat_id: chat_id,
+      input_message_content: {
+        "@type": "inputMessageText",
+        text: { "@type": "formattedText", text: "pong" }
+      }
+    )
+  when "/lock"
+    gm.set_slow_mode(chat_id: chat_id, delay: 30)
+  when "/title"
+    gm.set_chat_title(chat_id: chat_id, title: "GrubY TDLib Room")
+  end
+end
+
+client.finalizer do |_update|
+end
+
+client.run

data/example/userbot.rb

@@ -0,0 +1,133 @@
+require_relative "../lib/grubY"
+
+begin
+  require "io/console"
+rescue LoadError
+end
+
+begin
+  require "rqrcode"
+rescue LoadError
+  RQRCode = nil
+end
+
+def clear_print
+  print "\e[2J\e[f"
+end
+
+def prompt(label)
+  print label
+  STDIN.gets.to_s.strip
+end
+
+api_id = ENV["TD_API_ID"]&.to_i
+api_hash = ENV["TD_API_HASH"]
+
+abort("Missing TD_API_ID or TD_API_HASH") if api_id.nil? || api_hash.to_s.empty?
+
+client = GrubY::TDLib::Client.new(
+  api_id: api_id,
+  api_hash: api_hash,
+  database_directory: "storage/tdlib-userbot",
+  files_directory: "storage/tdlib-userbot/files",
+  tdjson_path: ENV["TDJSON_PATH"],
+  td_verbosity: 2,
+  options: {
+    "ignore_background_updates" => false
+  },
+  workers: 4,
+  default_handler_timeout: 15
+)
+
+client.on("updateAuthorizationState") do |update|
+  state = update.dig("authorization_state", "@type")
+
+  case state
+  when "authorizationStateWaitPhoneNumber"
+    loop do
+      input = prompt('Enter phone number or "qr": ')
+      next if input.empty?
+
+      if input.downcase == "qr"
+        res = client.request_qr_code_authentication
+        if res["@type"] == "error"
+          puts "Error: #{res['message']}"
+          next
+        end
+      else
+        res = client.set_authentication_phone_number(phone_number: input)
+        if res["@type"] == "error"
+          puts "Error: #{res['message']}"
+          next
+        end
+      end
+
+      break
+    end
+  when "authorizationStateWaitOtherDeviceConfirmation"
+    link = update.dig("authorization_state", "link")
+    clear_print
+    puts "Scan QR from Telegram mobile app -> Settings -> Devices -> Link Desktop Device"
+    puts
+    puts link
+
+    if RQRCode
+      puts
+      qr = RQRCode::QRCode.new(link)
+      qr.modules.each do |row|
+        puts row.map { |m| m ? "##" : "  " }.join
+      end
+    else
+      puts "\nInstall `rqrcode` gem for terminal QR rendering."
+    end
+  when "authorizationStateWaitCode"
+    loop do
+      code = prompt("Enter login code: ")
+      next if code.empty?
+
+      res = client.check_authentication_code(code)
+      if res["@type"] == "error"
+        puts "Error: #{res['message']}"
+        next
+      end
+      break
+    end
+  when "authorizationStateWaitPassword"
+    clear_print
+    hint = update.dig("authorization_state", "password_hint")
+    loop do
+      pass = prompt("Enter 2FA password (hint: #{hint}): ")
+      next if pass.empty?
+
+      res = client.check_authentication_password(pass)
+      if res["@type"] == "error"
+        puts "Error: #{res['message']}"
+        next
+      end
+      break
+    end
+  when "authorizationStateReady"
+    me = client.get_me
+    clear_print
+    puts "Logged in as #{me['first_name']} (ID: #{me['id']})"
+  end
+end
+
+client.on_message do |message|
+  next unless message.dig("content", "@type") == "messageText"
+  next unless message["is_outgoing"]
+
+  text = message.dig("content", "text", "text").to_s
+  next unless text == "!hi"
+
+  client.edit_message_text(
+    chat_id: message["chat_id"],
+    message_id: message["id"],
+    input_message_content: {
+      "@type" => "inputMessageText",
+      "text" => { "@type" => "formattedText", "text" => "Hey, This is from GrubY TDLib Userbot!" }
+    }
+  )
+end
+
+client.run