wabot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ffe9be4b97b0465e99c58023ae6e95738d3303cecafe11837c005d2e3cdfadae
+  data.tar.gz: 25861a984ae565f07f83e5db58389f5eb78274761b2912e4107e8dbe9ea6e598
+SHA512:
+  metadata.gz: a6bf9f916fb6b428d4ab78322fa87fdc494a96c8a49c2144b2b6dd81bcdd7a9304920a3809e6acadcaeb05488fad0579f4bb425199f4e8f2ceaa0a079db18932
+  data.tar.gz: 40a6a9425863422b93f275b5d3f49b526bbcff28977ed863e613aea3923e0f78c7c824630ae98d84fabcc578a85002bb25af7ff75022f63cc1e0a76b5f7c4fab

data/README.md

@@ -0,0 +1,105 @@
+# WaBot (Ruby)
+
+A simple personal WhatsApp Web bot using Ruby, Selenium, and WhatsApp Web. No WhatsApp Business API required.
+
+Features:
+- Register/login local users (credentials stored locally, password hashed with bcrypt)
+- Persist WhatsApp Web session per user via Chrome profile directory
+- CLI to login to WhatsApp Web (QR) and send messages
+
+## Prerequisites
+- Ruby 3.0+
+- Google Chrome installed
+
+## Setup
+```
+cd wabot
+bundle install
+```
+
+Note: This project uses Selenium Manager (built into selenium-webdriver >= 4.11) to automatically manage the browser driver. You do NOT need the `webdrivers` gem.
+
+## Usage
+1) Register a local user:
+```
+ruby bin/wabot register -u alice -p secret123
+```
+
+2) Login as that local user:
+```
+ruby bin/wabot login -u alice -p secret123
+```
+
+3) Log in to WhatsApp Web (scan QR once). A Chrome window will open:
+```
+ruby bin/wabot wa_login
+```
+Wait until you see your chat list.
+
+4) Send a message (reuses the saved WhatsApp Web session for the current user):
+```
+ruby bin/wabot send -t "+1234567890" -m "Hello from WaBot!"
+```
+
+Notes:
+- Phone number must be in international format including country code, e.g., +14155552671
+- Each local user gets a separate Chrome profile under `profiles/<username>` to persist WhatsApp login
+ - Selenium Manager will handle downloading a compatible chromedriver automatically
+
+## Security
+- Local user passwords are hashed with bcrypt and stored in `storage/users.json`
+- The current CLI login session is stored in `storage/session.json`
+- Your WhatsApp Web cookies/tokens live inside `profiles/<username>`; keep this folder private
+
+## Troubleshooting
+- If WhatsApp Web UI changes and selectors break, update selectors in `lib/wabot/bot.rb`
+- If Chrome fails to start in headless on macOS, try without `--headless` (default)
+- Clear a user's WhatsApp session by deleting `profiles/<username>` (you'll need to scan QR again)
+
+## Gem usage (Ruby API)
+
+You can use this as a library in your own Ruby code. Build and install the gem locally:
+
+```
+cd wabot
+gem build wabot.gemspec
+gem install ./wabot-0.1.0.gem
+```
+
+Then, in your Ruby app:
+
+```ruby
+require "wabot"
+
+# First-time only: open a visible window and log in (scan QR)
+WaBot.login(username: "alice", headless: false)
+
+# Later: open a session and send multiple messages inside a block
+WaBot.session(username: "alice", headless: true) do |bot|
+  bot.send_message(phone_number: "+14155552671", message: "Hello from WaBot")
+  bot.send_message(phone_number: "+14155552672", message: "Second message")
+end
+```
+
+Using with Bundler (Gemfile):
+
+```
+gem "wabot", "~> 0.1.0"
+```
+
+Then in code:
+
+```ruby
+require "wabot"
+```
+
+CLI when installed via gem:
+
+```
+wabot login -u alice
+wabot send -t "+1234567890" -m "Hello from WaBot" --headless
+```
+
+Notes:
+- Library defaults to storing Chrome profiles under `~/.wabot/profiles/<username>` so your session persists across uses.
+- If you prefer a visible browser for debugging, set `headless: false` in `WaBot.session(...)`.

data/bin/wabot

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "wabot/cli"
+
+WaBot::CLI.start(ARGV)

data/lib/wabot/bot.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "selenium-webdriver"
+require "fileutils"
+require "uri"
+
+module WaBot
+  class Bot
+    BASE_URL = "https://web.whatsapp.com"
+
+    def initialize(username:, base_dir: File.expand_path("~/.wabot"), headless: false)
+      @username = username
+      @base_dir = base_dir
+      @profiles_dir = File.join(@base_dir, "profiles")
+      FileUtils.mkdir_p(@profiles_dir)
+      @user_profile_dir = File.join(@profiles_dir, username)
+      FileUtils.mkdir_p(@user_profile_dir)
+      @driver = nil
+      @headless = headless
+    end
+
+    def start
+      opts = Selenium::WebDriver::Chrome::Options.new
+      opts.add_argument("--user-data-dir=#{@user_profile_dir}")
+      opts.add_argument("--no-sandbox")
+      opts.add_argument("--disable-dev-shm-usage")
+      opts.add_argument("--window-size=1280,900")
+      opts.add_argument("--headless=new") if @headless
+
+      @driver = Selenium::WebDriver.for(:chrome, options: opts)
+      @driver.navigate.to(BASE_URL)
+    end
+
+    def ensure_logged_in(timeout: 90)
+      wait = Selenium::WebDriver::Wait.new(timeout: timeout)
+      begin
+        wait.until do
+          begin
+            @driver.find_element(css: "div[data-testid='chat-list']")
+          rescue Selenium::WebDriver::Error::NoSuchElementError
+            begin
+              @driver.find_element(css: "div[aria-label='Chat list']")
+            rescue Selenium::WebDriver::Error::NoSuchElementError
+              nil
+            end
+          end
+        end
+        true
+      rescue Selenium::WebDriver::Error::TimeoutError
+        false
+      end
+    end
+
+    def send_message(phone_number:, message:)
+      ensure_driver!
+      # WhatsApp expects digits only (no '+', spaces, hyphens)
+      digits_phone = phone_number.to_s.gsub(/\D/, "")
+      encoded_text = URI.encode_www_form_component(message)
+      chat_url = "#{BASE_URL}/send?phone=#{digits_phone}&text=#{encoded_text}"
+      @driver.navigate.to(chat_url)
+
+      wait = Selenium::WebDriver::Wait.new(timeout: 60)
+      begin
+        # Wait until the message box (preferred) or a send button is visible
+        wait.until { !!(find_message_box || find_send_button) }
+
+        # Always attempt to type the message explicitly to avoid relying on URL prefill
+        box = find_message_box
+        if box
+          box.click
+          sleep 0.15
+          # Select-all + delete to clear any previous text
+          modifier = (RUBY_PLATFORM =~ /darwin/i ? :command : :control)
+          box.send_keys([modifier, 'a'])
+          box.send_keys(:backspace)
+          sleep 0.05
+          box.send_keys(message)
+          sleep 0.1
+        end
+
+        # Prefer clicking the send button if present
+        if (btn = find_send_button)
+          begin
+            @driver.execute_script("arguments[0].click();", btn)
+          rescue
+            btn.click
+          end
+        else
+          # If no button, try Enter/Return inside the composer
+          if box
+            box.send_keys(:enter)
+            sleep 0.2
+            unless composer_text.to_s.strip.empty?
+              box.send_keys(:return)
+            end
+          else
+            # As a last resort, press Enter/Return on body
+            body = @driver.find_element(tag_name: "body")
+            body.send_keys(:enter)
+            sleep 0.2
+            # Try :return if still not sent
+            if composer_text && !composer_text.to_s.strip.empty?
+              body.send_keys(:return)
+            end
+          end
+        end
+
+        # Primary verification: new outgoing bubble with the same text appears
+        begin
+          Selenium::WebDriver::Wait.new(timeout: 8).until do
+            message_sent?(message)
+          end
+          return true
+        rescue Selenium::WebDriver::Error::TimeoutError
+          # Secondary verification: composer cleared
+          begin
+            Selenium::WebDriver::Wait.new(timeout: 3).until do
+              current = composer_text
+              current.nil? || current.strip.empty?
+            end
+            return true
+          rescue Selenium::WebDriver::Error::TimeoutError
+            return false
+          end
+        end
+      rescue Selenium::WebDriver::Error::TimeoutError
+        # Timed out waiting; try body Enter
+        body = @driver.find_element(tag_name: "body")
+        body.send_keys(:enter)
+        true
+      rescue => e
+        warn "Failed to send message: #{e.message}"
+        false
+      end
+    end
+
+    # Convenience alias
+    def send_to(phone_number, text)
+      send_message(phone_number: phone_number, message: text)
+    end
+
+    def close
+      @driver&.quit
+      @driver = nil
+    end
+
+    private
+
+    def ensure_driver!
+      raise "Driver not started. Call start first." unless @driver
+    end
+
+    def find_message_box
+      # Try several known selectors WhatsApp uses for the main composer textbox
+      candidates = [
+        "div[data-testid='conversation-compose-box-input']",
+        "div[contenteditable='true'][data-tab='10']",
+        "div[contenteditable='true'][data-tab='6']",
+        "div[role='textbox'][contenteditable='true']",
+        "div[aria-label='Type a message']",
+        "div[title='Type a message']"
+      ]
+      candidates.each do |css|
+        begin
+          el = @driver.find_element(css: css)
+          return el if el.displayed?
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+        end
+      end
+      nil
+    end
+
+    def find_send_button
+      # Try multiple variants for the send button
+      css_candidates = [
+        "button[data-testid='compose-btn-send']",
+        "button[aria-label='Send']",
+        "button[aria-label='Send message']"
+      ]
+      css_candidates.each do |css|
+        begin
+          el = @driver.find_element(css: css)
+          return el if el.displayed?
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+        end
+      end
+      # Older UI: span icon
+      begin
+        span = @driver.find_element(css: "span[data-icon='send']")
+        return span.find_element(xpath: "./ancestor::button")
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+      end
+      nil
+    end
+
+    def composer_text
+      el = find_message_box
+      return nil unless el
+      el.text
+    rescue
+      nil
+    end
+
+    def message_sent?(text)
+      begin
+        # Look for outgoing message bubbles containing our text
+        nodes = @driver.find_elements(css: "div.message-out span.selectable-text, div.message-out span[dir='auto']")
+        nodes.any? { |n| n.text.to_s.strip == text.to_s.strip }
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/wabot/cli.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "thor"
+require "colorize"
+require_relative "version"
+require_relative "user_store"
+require_relative "session_store"
+require_relative "bot"
+
+module WaBot
+  class CLI < Thor
+    desc "register", "Register a new local user"
+    method_option :username, aliases: "-u", type: :string, required: true, desc: "Username"
+    method_option :password, aliases: "-p", type: :string, required: true, desc: "Password"
+    def register
+      store = UserStore.new
+      begin
+        store.register(options[:username], options[:password])
+        puts "User registered: #{options[:username]}".green
+      rescue => e
+        puts "Error: #{e.message}".red
+        exit 1
+      end
+    end
+
+    desc "login", "Login as a local user"
+    method_option :username, aliases: "-u", type: :string, required: true
+    method_option :password, aliases: "-p", type: :string, required: true
+    def login
+      store = UserStore.new
+      unless store.authenticate(options[:username], options[:password])
+        puts "Invalid username or password".red
+        exit 1
+      end
+      session = SessionStore.new
+      session.login(options[:username])
+      puts "Logged in as #{options[:username]}".green
+    end
+
+    desc "logout", "Logout current local user"
+    def logout
+      session = SessionStore.new
+      if session.logged_in?
+        user = session.current_user
+        session.logout
+        puts "Logged out: #{user}".yellow
+      else
+        puts "No user is currently logged in".yellow
+      end
+    end
+
+    desc "wa_login", "Open WhatsApp Web to log in (QR) for the current user"
+    method_option :headless, type: :boolean, default: false, desc: "Run Chrome in headless mode"
+    def wa_login
+      session = SessionStore.new
+      unless session.logged_in?
+        puts "Please login as a local user first (cli login)".red
+        exit 1
+      end
+
+      bot = Bot.new(username: session.current_user, headless: options[:headless])
+      begin
+        bot.start
+        puts "A Chrome window has opened. Scan the QR code with your phone to login to WhatsApp Web.".cyan
+        if bot.ensure_logged_in(timeout: 180)
+          puts "WhatsApp Web login successful!".green
+        else
+          puts "Timed out waiting for WhatsApp Web login.".red
+        end
+      ensure
+        bot.close
+      end
+    end
+
+    desc "send", "Send a WhatsApp message"
+    method_option :to, aliases: "-t", type: :string, required: true, desc: "Phone number in international format, e.g. +1234567890"
+    method_option :message, aliases: "-m", type: :string, required: true, desc: "Message text"
+    method_option :headless, type: :boolean, default: false
+    method_option :keep_open, type: :boolean, default: false, desc: "Keep the browser open after sending (debug)"
+    def send
+      session = SessionStore.new
+      unless session.logged_in?
+        puts "Please login as a local user first (cli login)".red
+        exit 1
+      end
+
+      bot = Bot.new(username: session.current_user, headless: options[:headless])
+      begin
+        bot.start
+        unless bot.ensure_logged_in(timeout: 180)
+          puts "Not logged into WhatsApp Web. Please run `wa_login` to scan the QR code first.".red
+          exit 1
+        end
+        if bot.send_message(phone_number: options[:to], message: options[:message])
+          puts "Message sent to #{options[:to]}".green
+        else
+          puts "Failed to send message".red
+          exit 1 unless options[:keep_open]
+        end
+        if options[:keep_open]
+          puts "Keeping browser open. Press Enter to quit...".yellow
+          STDIN.gets
+        end
+      ensure
+        bot.close unless options[:keep_open]
+      end
+    end
+
+    desc "version", "Print version"
+    def version
+      puts WaBot::VERSION
+    end
+  end
+end

data/lib/wabot/session_store.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+
+module WaBot
+  class SessionStore
+    def initialize(base_dir: File.expand_path("~/.wabot"))
+      @storage_dir = File.join(base_dir, "storage")
+      FileUtils.mkdir_p(@storage_dir)
+      @session_file = File.join(@storage_dir, "session.json")
+      initialize_file
+    end
+
+    def login(username)
+      data = { "current_user" => username, "logged_in_at" => Time.now.utc.iso8601 }
+      File.write(@session_file, JSON.pretty_generate(data))
+      true
+    end
+
+    def current_user
+      data = JSON.parse(File.read(@session_file))
+      data["current_user"]
+    rescue
+      nil
+    end
+
+    def logged_in?
+      !current_user.nil?
+    end
+
+    def logout
+      File.write(@session_file, JSON.pretty_generate({ "current_user" => nil }))
+      true
+    end
+
+    private
+
+    def initialize_file
+      unless File.exist?(@session_file)
+        File.write(@session_file, JSON.pretty_generate({ "current_user" => nil }))
+      end
+    end
+  end
+end

data/lib/wabot/user_store.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+require "bcrypt"
+require "fileutils"
+
+module WaBot
+  class UserStore
+    def initialize(base_dir: File.expand_path("~/.wabot"))
+      @storage_dir = File.join(base_dir, "storage")
+      FileUtils.mkdir_p(@storage_dir)
+      @users_file = File.join(@storage_dir, "users.json")
+      initialize_file
+    end
+
+    def register(username, password)
+      raise "Username is required" if username.to_s.strip.empty?
+      raise "Password is required" if password.to_s.strip.empty?
+
+      users = read_users
+      raise "User already exists" if users.any? { |u| u["username"] == username }
+
+      password_hash = BCrypt::Password.create(password)
+      users << { "username" => username, "password_hash" => password_hash }
+      write_users(users)
+      true
+    end
+
+    def authenticate(username, password)
+      users = read_users
+      user = users.find { |u| u["username"] == username }
+      return false unless user
+
+      begin
+        BCrypt::Password.new(user["password_hash"]) == password
+      rescue
+        false
+      end
+    end
+
+    def users
+      read_users
+    end
+
+    private
+
+    def initialize_file
+      unless File.exist?(@users_file)
+        File.write(@users_file, JSON.pretty_generate({ users: [] }))
+      end
+    end
+
+    def read_users
+      data = JSON.parse(File.read(@users_file))
+      data["users"] || []
+    rescue
+      []
+    end
+
+    def write_users(users)
+      File.write(@users_file, JSON.pretty_generate({ users: users }))
+    end
+  end
+end

data/lib/wabot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WaBot
+  VERSION = "0.1.0"
+end

data/lib/wabot.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "wabot/version"
+require_relative "wabot/bot"
+
+module WaBot
+  # Open a WhatsApp Web browser session for a given username and yield the bot.
+  # Ensures the browser is closed after the block even if an error occurs.
+  #
+  # Example:
+  #   WaBot.session(username: "alice") do |bot|
+  #     bot.send_message(phone_number: "+14155552671", message: "Hello")
+  #     bot.send_message(phone_number: "+14155552672", message: "Hi again")
+  #   end
+  #
+  # Options:
+  # - headless: run Chrome headless (default: false)
+  # - timeout: seconds to wait for WhatsApp Web chat list (default: 180)
+  # - base_dir: base directory for profiles/ and storage/ (default: ~/.wabot)
+  # - require_login: if true, waits for chat list; if false, skips the check (default: true)
+  def self.session(username:, headless: false, timeout: 180, base_dir: File.expand_path("~/.wabot"), require_login: true)
+    bot = Bot.new(username: username, headless: headless, base_dir: base_dir)
+    begin
+      bot.start
+      if require_login
+        ok = bot.ensure_logged_in(timeout: timeout)
+        unless ok
+          raise "Not logged into WhatsApp Web for user '#{username}'. Run wa_login or open a non-headless session to scan QR."
+        end
+      end
+      yield bot
+    ensure
+      bot.close
+    end
+  end
+
+  # Convenience: open a session, send one message, and close.
+  def self.send_message(username:, to:, message:, headless: false, timeout: 180, base_dir: File.expand_path("~/.wabot"))
+    session(username: username, headless: headless, timeout: timeout, base_dir: base_dir) do |bot|
+      bot.send_message(phone_number: to, message: message)
+    end
+  end
+
+  # Open a visible Chrome window and wait for QR login (up to timeout seconds).
+  # Returns true if chat list detected, false otherwise.
+  def self.login(username:, timeout: 180, base_dir: File.expand_path("~/.wabot"), headless: false)
+    bot = Bot.new(username: username, headless: headless, base_dir: base_dir)
+    begin
+      bot.start
+      bot.ensure_logged_in(timeout: timeout)
+    ensure
+      bot.close
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: wabot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vikas Kumar
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Automate WhatsApp Web from Ruby using Selenium. Provides a CLI and a
+  Ruby API with block-based session handling.
+email:
+- vikas_kr@live.com
+executables:
+- wabot
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/wabot
+- lib/wabot.rb
+- lib/wabot/bot.rb
+- lib/wabot/cli.rb
+- lib/wabot/session_store.rb
+- lib/wabot/user_store.rb
+- lib/wabot/version.rb
+homepage: https://github.com/vikas-0/whatsapp_bot_ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: 'WaBot: Personal WhatsApp Web automation with CLI and block-based API'
+test_files: []