whatsapp_notifier 0.2.0

data/lib/whatsapp_notifier/services/web_automation/index.ts

@@ -0,0 +1,285 @@
+import { Client, LocalAuth } from 'whatsapp-web.js';
+import { Hono } from 'hono';
+import { rmSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { toDataURL } from 'qrcode';
+
+const app = new Hono();
+const port = Number(process.env.PORT || 3001);
+const SESSION_BASE_DIR = process.env.WHATSAPP_SESSION_DIR || '/whatsapp_data';
+const BROWSER_EXECUTABLE_PATH = process.env.PUPPETEER_EXECUTABLE_PATH;
+
+// Multi-user client management
+interface ClientData {
+    client: Client;
+    state: 'INITIALIZING' | 'QR_REQUIRED' | 'AUTHENTICATED' | 'DISCONNECTED';
+    qr: string | null;
+    lastUsed: number;
+    isDestroying?: boolean;
+    ready?: boolean;
+}
+
+const clients = new Map<string, ClientData>();
+
+function sessionDirForUser(userId: string) {
+    return join(SESSION_BASE_DIR, `session-user-${userId}`);
+}
+
+function clearChromiumSingletonLocks(userId: string) {
+    const lockFiles = ['SingletonLock', 'SingletonSocket', 'SingletonCookie', 'lockfile'];
+
+    // Clean locks from session dir and all subdirectories recursively
+    function cleanDir(dir: string) {
+        if (!existsSync(dir)) return;
+
+        lockFiles.forEach((fileName) => {
+            const filePath = join(dir, fileName);
+            try {
+                rmSync(filePath, { force: true });
+            } catch (e) {
+                // Ignore
+            }
+        });
+
+        try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    cleanDir(join(dir, entry.name));
+                }
+            }
+        } catch (_) { /* ignore permission errors on nested dirs */ }
+    }
+
+    cleanDir(sessionDirForUser(userId));
+    // Also clean the base session dir itself
+    cleanDir(SESSION_BASE_DIR);
+}
+
+function isTransientSendError(error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("getChat") || message.includes("Cannot read properties of undefined");
+}
+
+async function waitForClientReady(clientData: ClientData, timeoutMs = 30000): Promise<void> {
+    if (clientData.ready) return;
+
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (clientData.ready) return;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error('Client not ready: WhatsApp Web store did not initialize in time');
+}
+
+async function sendMessageWithRetry(client: Client, clientData: ClientData, chatId: string, message: string, mediaUrl?: string | null) {
+    const maxAttempts = 5;
+
+    // Wait for the internal WWeb store to be fully loaded before first attempt
+    await waitForClientReady(clientData);
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            if (mediaUrl) {
+                const { MessageMedia } = require('whatsapp-web.js');
+                const media = await MessageMedia.fromUrl(mediaUrl);
+                await client.sendMessage(chatId, media, { caption: message });
+            } else {
+                await client.sendMessage(chatId, message);
+            }
+
+            return;
+        } catch (error) {
+            console.error(`Send attempt ${attempt}/${maxAttempts} failed for chat ${chatId}:`, error);
+
+            if (!isTransientSendError(error) || attempt === maxAttempts) {
+                throw error;
+            }
+
+            // Wait longer between retries to give the store time to hydrate
+            await new Promise((resolve) => setTimeout(resolve, attempt * 3000));
+        }
+    }
+}
+
+// Helper to get or create a client for a user
+async function getOrCreateClient(userId: string): Promise<ClientData> {
+    if (clients.has(userId)) {
+        const data = clients.get(userId)!;
+        if (data.isDestroying) return data;
+        data.lastUsed = Date.now();
+        return data;
+    }
+
+    console.log(`Initializing new WhatsApp client for User: ${userId}`);
+    clearChromiumSingletonLocks(userId);
+    
+    const client = new Client({
+        authStrategy: new LocalAuth({ 
+            clientId: `user-${userId}`,
+            dataPath: SESSION_BASE_DIR
+        }),
+        puppeteer: {
+            headless: true,
+            args: [
+                '--no-sandbox', 
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu'
+            ],
+            ...(BROWSER_EXECUTABLE_PATH ? { executablePath: BROWSER_EXECUTABLE_PATH } : {})
+        }
+    });
+
+    const clientData: ClientData = {
+        client,
+        state: 'INITIALIZING',
+        qr: null,
+        lastUsed: Date.now(),
+        ready: false
+    };
+
+    clients.set(userId, clientData);
+
+    client.on('qr', async (qr) => {
+        clientData.state = 'QR_REQUIRED';
+        try {
+            clientData.qr = await toDataURL(qr);
+            console.log(`QR RECEIVED and converted for User ${userId}`);
+        } catch (err) {
+            console.error('Failed to convert QR to DataURL', err);
+        }
+    });
+
+    client.on('ready', () => {
+        clientData.state = 'AUTHENTICATED';
+        clientData.qr = null;
+        clientData.ready = true;
+        console.log(`Client is READY for User ${userId}`);
+    });
+
+    client.on('authenticated', () => {
+        clientData.state = 'AUTHENTICATED';
+        clientData.ready = false;
+        console.log(`AUTHENTICATED for User ${userId}`);
+    });
+
+    client.on('auth_failure', (msg) => {
+        clientData.state = 'DISCONNECTED';
+        clientData.ready = false;
+        console.error(`AUTHENTICATION FAILURE for User ${userId}`, msg);
+    });
+
+    client.on('disconnected', (reason) => {
+        clientData.state = 'DISCONNECTED';
+        clientData.ready = false;
+        console.log(`User ${userId} was logged out`, reason);
+        destroyClient(userId).catch(console.error);
+    });
+
+    client.initialize().catch(err => {
+        console.error(`Initialization failed for user ${userId}`, err);
+        clients.delete(userId);
+    });
+
+    return clientData;
+}
+
+async function destroyClient(userId: string) {
+    const data = clients.get(userId);
+    if (data && !data.isDestroying) {
+        data.isDestroying = true;
+        console.log(`Destroying WhatsApp client for User: ${userId}`);
+        try {
+            // Unregister listeners to prevent loops or double-destroys
+            data.client.removeAllListeners();
+            await data.client.destroy();
+        } catch (e) {
+            console.error(`Error destroying client for ${userId}`, e);
+        }
+        clients.delete(userId);
+
+        // Optional: Clean up session files and puppeteer profiles if it was a logout
+        const userPath = sessionDirForUser(userId);
+        
+        if (existsSync(userPath)) {
+            try {
+                rmSync(userPath, { recursive: true, force: true });
+                console.log(`Cleaned up user data directory: ${userPath}`);
+            } catch (e) {
+                console.error(`Failed to delete directory: ${userPath}`, e);
+            }
+        }
+    }
+}
+
+// 72-hour stagnation cleanup
+setInterval(() => {
+    const now = Date.now();
+    const STAGNATION_LIMIT = 72 * 60 * 60 * 1000; // 72 hours
+
+    for (const [userId, data] of clients.entries()) {
+        if (now - data.lastUsed > STAGNATION_LIMIT) {
+            console.log(`Auto-cleaning stagnant session for User: ${userId}`);
+            destroyClient(userId).catch(console.error);
+        }
+    }
+}, 60 * 60 * 1000); // Check every hour
+
+// API Routes
+app.get('/status/:userId', async (c) => {
+    const userId = c.req.param('userId');
+    const data = await getOrCreateClient(userId);
+    return c.json({
+        state: data.state,
+        authenticated: data.state === 'AUTHENTICATED' && !!data.ready,
+        hasQR: !!data.qr
+    });
+});
+
+app.get('/qr/:userId', async (c) => {
+    const userId = c.req.param('userId');
+    const data = await getOrCreateClient(userId);
+    return c.json({ qr: data.qr });
+});
+
+app.post('/send/:userId', async (c) => {
+    const userId = c.req.param('userId');
+    const { to, message, mediaUrl } = await c.req.json();
+    if (!to || !message) {
+        return c.json({ success: false, error: 'Both `to` and `message` are required' }, 422);
+    }
+    const data = await getOrCreateClient(userId);
+
+    if (data.state !== 'AUTHENTICATED' || !data.ready) {
+        return c.json({ success: false, error: 'User not authenticated' }, 401);
+    }
+
+    try {
+        const chatId = to.includes('@c.us') ? to : `${to}@c.us`;
+        await sendMessageWithRetry(data.client, data, chatId, message, mediaUrl);
+
+        data.lastUsed = Date.now();
+        return c.json({ success: true });
+    } catch (error: any) {
+        console.error(`Send error for user ${userId}:`, error);
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+
+
+console.log(`Starting Multi-User WhatsApp service (Bun Native) on port ${port}...`);
+
+process.on('exit', (code) => {
+    console.log(`BUN PROCESS EXITING WITH CODE: ${code}`);
+});
+
+process.on('SIGTERM', () => {
+    console.log('BUN RECEIVED SIGTERM');
+    process.exit(0);
+});
+
+// Correct way to keep Bun process alive with Hono
+export default Bun.serve({
+  port: port,
+  fetch: app.fetch,
+});

data/lib/whatsapp_notifier/services/web_automation/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "whatsapp-service",
+  "version": "1.0.0",
+  "main": "index.ts",
+  "dependencies": {
+    "hono": "4.12.15",
+    "whatsapp-web.js": "1.34.7",
+    "qrcode": "1.5.4",
+    "puppeteer": "22.15.0"
+  },
+  "devDependencies": {
+    "bun-types": "1.3.13"
+  }
+}

data/lib/whatsapp_notifier/session/qr_service.rb

@@ -0,0 +1,51 @@
+module WhatsAppNotifier
+  module Session
+    class QrService
+      attr_reader :store, :adapter
+
+      def initialize(store:, adapter:)
+        @store = store
+        @adapter = adapter
+      end
+
+      def qr_code(metadata: {})
+        session = store.load
+        user_id = metadata[:user_id]
+        cached = cached_qr(session, user_id)
+        return cached if cached
+
+        generated = adapter.fetch_qr_code(metadata: metadata)
+        store.save(with_cached_qr(session, user_id, generated))
+        generated
+      end
+
+
+      def activate!(token)
+        session = store.load
+        store.save(session.merge(active: true, token: token, qr_code: nil))
+      end
+
+      private
+
+      def cached_qr(session, user_id)
+        return session[:qr_code] unless user_id
+
+        session.fetch(:users, {}).fetch(user_key(user_id), {})[:qr_code]
+      end
+
+      def with_cached_qr(session, user_id, qr_code)
+        return session.merge(qr_code: qr_code) unless user_id
+
+        users = session.fetch(:users, {})
+        key = user_key(user_id)
+        user_session = users.fetch(key, {})
+        users[key] = user_session.merge(qr_code: qr_code)
+        session.merge(users: users)
+      end
+
+      def user_key(user_id)
+        user_id.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/whatsapp_notifier/session/store.rb

@@ -0,0 +1,22 @@
+require "json"
+require "fileutils"
+
+module WhatsAppNotifier
+  module Session
+    class Store
+      def initialize(path:)
+        @path = path
+      end
+
+      def load
+        return {} unless File.exist?(@path)
+        JSON.parse(File.read(@path), symbolize_names: true)
+      end
+
+      def save(data)
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, JSON.generate(data))
+      end
+    end
+  end
+end

data/lib/whatsapp_notifier/version.rb

@@ -0,0 +1,4 @@
+module WhatsAppNotifier
+  VERSION = "0.2.0"
+
+end

data/lib/whatsapp_notifier/web_adapter.rb

@@ -0,0 +1,72 @@
+require "json"
+require "net/http"
+require "uri"
+
+module WhatsAppNotifier
+  class WebAdapter
+    def initialize(base_url: ENV.fetch("WHATSAPP_NOTIFIER_SERVICE_URL", "http://127.0.0.1:3001"))
+      @base_url = base_url
+    end
+
+    def send_message(payload:, session: {})
+      user_id = user_id_from(payload[:metadata] || {})
+      body = {
+        to: payload[:to],
+        message: payload[:body],
+        mediaUrl: payload.dig(:metadata, :media_url)
+      }.compact
+
+      response = request(:post, "/send/#{user_id}", body: body)
+      {
+        success: response.fetch("success"),
+        message_id: payload[:idempotency_key] || "local-#{Time.now.to_i}",
+        session: session,
+        error_message: response["error"]
+      }
+    end
+
+    def fetch_qr_code(metadata: {})
+      user_id = user_id_from(metadata)
+      response = request(:get, "/qr/#{user_id}")
+      response["qr"]
+    end
+
+    def connection_status(metadata: {})
+      user_id = user_id_from(metadata)
+      response = request(:get, "/status/#{user_id}")
+      {
+        state: response["state"],
+        authenticated: response["authenticated"],
+        has_qr: response["hasQR"]
+      }
+    end
+
+    private
+
+    def user_id_from(metadata)
+      (metadata[:user_id] || metadata["user_id"] || "default").to_s
+    end
+
+    def request(method, path, body: nil)
+      uri = URI.parse("#{@base_url}#{path}")
+      klass = method == :post ? Net::HTTP::Post : Net::HTTP::Get
+      req = klass.new(uri.request_uri)
+      req["Content-Type"] = "application/json"
+      req.body = JSON.generate(body) if body
+
+      res = Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }
+      parsed = parse_body(res.body)
+      return parsed if res.is_a?(Net::HTTPSuccess)
+
+      raise "service request failed (#{res.code}): #{parsed["error"] || res.body}"
+    end
+
+    def parse_body(raw)
+      return {} if raw.to_s.strip.empty?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      { "error" => raw }
+    end
+  end
+end

data/lib/whatsapp_notifier.rb

@@ -0,0 +1,72 @@
+require_relative "whatsapp_notifier/version"
+require_relative "whatsapp_notifier/errors"
+require_relative "whatsapp_notifier/result"
+require_relative "whatsapp_notifier/configuration"
+require_relative "whatsapp_notifier/web_adapter"
+require_relative "whatsapp_notifier/providers/base"
+require_relative "whatsapp_notifier/session/store"
+require_relative "whatsapp_notifier/session/qr_service"
+require_relative "whatsapp_notifier/providers/web_automation"
+require_relative "whatsapp_notifier/doctor"
+require_relative "whatsapp_notifier/bulk/rate_limiter"
+require_relative "whatsapp_notifier/bulk/retry_policy"
+require_relative "whatsapp_notifier/bulk/dispatcher"
+require_relative "whatsapp_notifier/client"
+require_relative "whatsapp_notifier/jobs/send_message_job"
+require_relative "whatsapp_notifier/notification"
+
+module WhatsAppNotifier
+  class << self
+    def configure
+      yield(configuration)
+      configuration.validate!
+      @client = Client.new(configuration: configuration)
+    end
+
+    def service_path
+      File.expand_path("whatsapp_notifier/services/web_automation", __dir__)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset!
+      @configuration = Configuration.new
+      @client = Client.new(configuration: @configuration)
+    end
+
+    def client
+      @client ||= Client.new(configuration: configuration)
+    end
+
+    def deliver(to:, body:, metadata: {}, provider: nil, idempotency_key: nil)
+      client.deliver(
+        to: to,
+        body: body,
+        metadata: metadata,
+        provider: provider,
+        idempotency_key: idempotency_key
+      )
+    end
+
+    def deliver_bulk(messages, provider: nil, sleeper: ->(seconds) { sleep(seconds) }, rng: Random.new)
+      client.deliver_bulk(messages, provider: provider, sleeper: sleeper, rng: rng)
+    end
+
+    def scan_qr(provider: nil, metadata: {})
+      client.scan_qr(provider: provider, metadata: metadata)
+    end
+
+    def connection_status(provider: nil, metadata: {})
+      client.connection_status(provider: provider, metadata: metadata)
+    end
+
+  end
+end
+
+# :nocov:
+if defined?(Rails::Railtie)
+  require_relative "whatsapp_notifier/railtie"
+end
+# :nocov:

data/spec/bulk/dispatcher_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Bulk::Dispatcher do
+  let(:config) do
+    WhatsAppNotifier::Configuration.new.tap do |c|
+      c.bulk_base_delay_seconds = 0
+      c.bulk_jitter_seconds = 0
+      c.bulk_max_recipients = 5
+      c.bulk_max_attempts = 2
+      c.bulk_retryable_error_codes = %i[rate_limited]
+    end
+  end
+
+  it "validates messages input type" do
+    dispatcher = described_class.new(client: double, configuration: config, sleeper: ->(_seconds) {})
+
+    expect { dispatcher.deliver("x") }.to raise_error(WhatsAppNotifier::ConfigurationError, /array/)
+  end
+
+  it "validates recipient limit" do
+    dispatcher = described_class.new(client: double, configuration: config, sleeper: ->(_seconds) {})
+    messages = Array.new(6) { { to: "+1", body: "a" } }
+
+    expect { dispatcher.deliver(messages) }.to raise_error(WhatsAppNotifier::ConfigurationError, /exceeded/)
+  end
+
+  it "delivers messages and summarizes result counts" do
+    client = double
+    allow(client).to receive(:deliver).and_return(
+      WhatsAppNotifier::Result.new(success: true, provider: :web_automation),
+      WhatsAppNotifier::Result.new(success: false, provider: :web_automation, error_code: :blocked)
+    )
+    dispatcher = described_class.new(client: client, configuration: config, sleeper: ->(_seconds) {})
+
+    summary = dispatcher.deliver([{ to: "+1", body: "a" }, { to: "+2", body: "b" }])
+
+    expect(summary[:total]).to eq(2)
+    expect(summary[:success]).to eq(1)
+    expect(summary[:failed]).to eq(1)
+  end
+
+  it "waits on provider wait_seconds and retries retryable failures" do
+    slept = []
+    client = double
+    allow(client).to receive(:deliver).and_return(
+      WhatsAppNotifier::Result.new(success: false, provider: :web_automation, error_code: :rate_limited),
+      WhatsAppNotifier::Result.new(success: true, provider: :web_automation, wait_seconds: 2)
+    )
+    dispatcher = described_class.new(client: client, configuration: config, sleeper: ->(seconds) { slept << seconds })
+
+    summary = dispatcher.deliver([{ to: "+1", body: "a" }])
+
+    expect(summary[:success]).to eq(1)
+    expect(slept).to include(2)
+    expect(client).to have_received(:deliver).twice
+  end
+
+  it "deduplicates idempotency keys within one bulk run" do
+    client = double
+    allow(client).to receive(:deliver).and_return(WhatsAppNotifier::Result.new(success: true, provider: :web_automation))
+    dispatcher = described_class.new(client: client, configuration: config, sleeper: ->(_seconds) {})
+
+    summary = dispatcher.deliver(
+      [
+        { to: "+1", body: "a", idempotency_key: "k1" },
+        { to: "+2", body: "b", idempotency_key: "k1" }
+      ]
+    )
+
+    expect(summary[:results].last.error_code).to eq(:duplicate_idempotency_key)
+    expect(client).to have_received(:deliver).once
+  end
+end

data/spec/bulk/rate_limiter_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Bulk::RateLimiter do
+  it "sleeps with base delay and jitter" do
+    slept = []
+    limiter = described_class.new(
+      base_delay: 1.0,
+      jitter: 0.5,
+      sleeper: ->(seconds) { slept << seconds },
+      rng: Random.new(123)
+    )
+
+    limiter.wait_before_next
+
+    expect(slept.length).to eq(1)
+    expect(slept.first).to be_between(1.0, 1.5)
+  end
+
+  it "does not sleep for non-positive delay" do
+    slept = []
+    limiter = described_class.new(base_delay: 0, jitter: 0, sleeper: ->(seconds) { slept << seconds })
+
+    limiter.wait_before_next
+
+    expect(slept).to be_empty
+  end
+end

data/spec/bulk/retry_policy_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+RSpec.describe WhatsAppNotifier::Bulk::RetryPolicy do
+  it "retries for retryable failures and returns final result" do
+    policy = described_class.new(max_attempts: 3, retryable_error_codes: %i[rate_limited])
+    attempts = 0
+
+    result = policy.with_retries do
+      attempts += 1
+      if attempts < 3
+        WhatsAppNotifier::Result.new(success: false, provider: :web_automation, error_code: :rate_limited)
+      else
+        WhatsAppNotifier::Result.new(success: true, provider: :web_automation)
+      end
+    end
+
+    expect(attempts).to eq(3)
+    expect(result).to be_success
+  end
+
+  it "does not retry non-retryable failures" do
+    policy = described_class.new(max_attempts: 3, retryable_error_codes: %i[rate_limited])
+    attempts = 0
+
+    result = policy.with_retries do
+      attempts += 1
+      WhatsAppNotifier::Result.new(success: false, provider: :web_automation, error_code: :blocked)
+    end
+
+    expect(attempts).to eq(1)
+    expect(result).to be_failure
+  end
+end