whatsapp_notifier 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0a1a6f1cfe29e873ffa53d25220906cc5dad9c8341d01dfec8f736602106f8
-  data.tar.gz: 0d24f4dab53b90178a2663c258540eb1abd6190a48354ab8a6aca921f08ea8ca
+  metadata.gz: '0202159fbe717a98a4bb69187abf75876258ce5f1d0bb1840deb46ed83096002'
+  data.tar.gz: df8857673fc57f8be6ba9681eb959d9aa842a051a522ceed530a19e57868d1b3
 SHA512:
-  metadata.gz: cc875e83f933373c8aa52c022859f1732726aa6634a513e3f202e664c459490b0212c418db5daff7e01af9461504211422b71a2e8ebba1b5e7113955279b0a0d
-  data.tar.gz: 1d2e6d912686b2dff1cd13483ca8043f5bd964df57d4365a49d1fec33cd31ae74b30e3e2bd480f1ca707b28f69e40368bc7d8fe1067f2c7fd4b861384d24af10
+  metadata.gz: a9618573ca58faba4ba1b98c69626caf7627288a1b490ea102b39053166d15552d83a30e7a2583db5702111a312cd33b6bdb7dc02c011d2f355161259532cc9a
+  data.tar.gz: 973ff970420fc87db0280f82758f2ba51cf6cc54189d0b1ea0a2ba84f43aaa993ec4938b6a606ebae0cb14bc38e314c832b6c56fb1622712433a64fb0eaa7c33

data/README.md

@@ -54,6 +54,20 @@ status = WhatsAppNotifier.connection_status(metadata: { user_id: current_user.id
 # => { state: "...", authenticated: true/false, has_qr: true/false }
 ```
 
+## Log out (disconnect + clear session)
+
+Explicitly disconnects the user and wipes their saved WhatsApp session from the
+service, so the next connect starts fresh with a new QR. Call this from a
+user-initiated "Log out WhatsApp" action — NOT from your app's sign-out, which
+should leave the WhatsApp session intact for the next login.
+
+```ruby
+WhatsAppNotifier.logout(metadata: { user_id: current_user.id })
+# => { success: true }
+```
+
+The mounted engine also exposes `DELETE /whatsapp/logout` for the same effect.
+
 ## Send a message
 
 ```ruby
@@ -120,6 +134,13 @@ This copies the service to `whatsapp_service/` and updates `.gitignore`.
 
 - This gem uses WhatsApp Web automation. Use responsibly and follow WhatsApp policies.
 - Keep Chromium available in your runtime (or set `PUPPETEER_EXECUTABLE_PATH`).
+- Session profiles persist under `WHATSAPP_SESSION_DIR` (default `/whatsapp_data`).
+  Mount it on durable storage so logins survive restarts; the service clears stale
+  Chromium `SingletonLock` files on each launch so an unclean exit can't wedge it.
+- Resilience knobs: `WHATSAPP_INIT_TIMEOUT_MS` (default 90000) recycles a client
+  that never reaches QR/READY; set `WWEBJS_WEB_VERSION` (e.g. `2.3000.1023204887`,
+  optionally `WWEBJS_WEB_VERSION_CACHE_URL`) to pin the WhatsApp Web build so a
+  live web.whatsapp.com change can't silently break the client.
 
 ## License
 

data/app/controllers/whatsapp_notifier/sessions_controller.rb

@@ -22,6 +22,16 @@ module WhatsAppNotifier
              status: :internal_server_error
     end
 
+    # DELETE /logout — disconnect WhatsApp and clear the saved session for the
+    # current user. Explicit, user-initiated; app sign-out must NOT call this.
+    def destroy
+      WhatsAppNotifier.logout(metadata: metadata)
+      render json: { success: true }
+    rescue StandardError => e
+      render json: { error: "Failed to log out: #{e.message}" },
+             status: :internal_server_error
+    end
+
     private
 
     def metadata

data/config/routes.rb

@@ -1,5 +1,6 @@
 WhatsAppNotifier::Engine.routes.draw do
-  get  "status", to: "sessions#show", as: :status
-  get  "qr",     to: "sessions#qr",   as: :qr
-  post "send",   to: "messages#create", as: :send_message
+  get    "status", to: "sessions#show",    as: :status
+  get    "qr",     to: "sessions#qr",      as: :qr
+  delete "logout", to: "sessions#destroy", as: :logout
+  post   "send",   to: "messages#create",  as: :send_message
 end

data/lib/whatsapp_notifier/client.rb

@@ -27,6 +27,10 @@ module WhatsAppNotifier
       provider_for(provider || @configuration.provider).connection_status(metadata: metadata)
     end
 
+    def logout(metadata: {}, provider: nil)
+      provider_for(provider || @configuration.provider).logout(metadata: metadata)
+    end
+
     private
 
     def provider_for(key)

data/lib/whatsapp_notifier/engine.rb

@@ -6,6 +6,20 @@ module WhatsAppNotifier
 
     config.whatsapp_notifier = {}
 
+    # The module name is WhatsAppNotifier (CapApp), but Zeitwerk's default
+    # inflector camelizes "whatsapp_notifier" -> "WhatsappNotifier" (single
+    # N). Without this override, controllers under app/controllers/
+    # whatsapp_notifier/ are indexed under the wrong constant and the
+    # host app gets "uninitialized constant WhatsAppNotifier::*" on every
+    # request to a mounted engine route. Inflect once for both autoloaders.
+    initializer "whatsapp_notifier.inflector", before: :set_autoload_paths do
+      mappings = { "whatsapp_notifier" => "WhatsAppNotifier" }
+      [Rails.autoloaders.main, Rails.autoloaders.once].each do |loader|
+        next unless loader.respond_to?(:inflector)
+        loader.inflector.inflect(mappings)
+      end
+    end
+
     initializer "whatsapp_notifier.configure" do |app|
       WhatsAppNotifier.configure do |config|
         app.config.whatsapp_notifier.each do |key, value|

data/lib/whatsapp_notifier/jobs/send_message_job.rb

@@ -1,6 +1,10 @@
 module WhatsAppNotifier
   module Jobs
     if defined?(::ActiveJob::Base)
+      # Real async path, only live in a host app that has ActiveJob loaded (any
+      # Rails app). Not exercisable in the gem's unit suite — the class is chosen
+      # at load time and ActiveJob isn't a gem dependency.
+      # :nocov:
       class SendMessageJob < ::ActiveJob::Base
         queue_as :default
 
@@ -9,6 +13,7 @@ module WhatsAppNotifier
           klass.with(params).deliver_now
         end
       end
+      # :nocov:
     else
       class SendMessageJob
         def self.perform_later(notification_class_name, params)

data/lib/whatsapp_notifier/providers/web_automation.rb

@@ -48,6 +48,15 @@ module WhatsAppNotifier
         adapter.connection_status(metadata: metadata)
       end
 
+      def logout(metadata: {})
+        raise ConfigurationError, "web automation provider is disabled" unless configuration.web_automation_enabled
+
+        adapter = configuration.web_adapter
+        raise ConfigurationError, "web_adapter must be configured for web_automation provider" unless adapter.respond_to?(:logout)
+
+        adapter.logout(metadata: metadata)
+      end
+
 
       private
 

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

@@ -9,6 +9,17 @@ 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;
 
+// Recycle a client that boots Chromium but never reaches QR/READY (e.g. after a
+// WhatsApp Web update breaks the injected store), instead of wedging in
+// INITIALIZING forever with no QR.
+const INIT_TIMEOUT_MS = Number(process.env.WHATSAPP_INIT_TIMEOUT_MS || 90000);
+// Optionally pin the WhatsApp Web build so a live web.whatsapp.com change can't
+// silently break the client. Set WWEBJS_WEB_VERSION to a known-good version
+// (e.g. "2.3000.1023204887"); leave unset to use the library default.
+const WEB_VERSION = process.env.WWEBJS_WEB_VERSION || null;
+const WEB_VERSION_CACHE_URL = process.env.WWEBJS_WEB_VERSION_CACHE_URL ||
+    'https://raw.githubusercontent.com/wppconnect-team/wa-version/main/html/{version}.html';
+
 // Multi-user client management
 interface ClientData {
     client: Client;
@@ -17,11 +28,19 @@ interface ClientData {
     lastUsed: number;
     isDestroying?: boolean;
     ready?: boolean;
+    initTimer?: ReturnType<typeof setTimeout>;
 }
 
 const clients = new Map<string, ClientData>();
 const initializingClients = new Set<string>();
 
+function clearInitTimer(clientData: ClientData) {
+    if (clientData.initTimer) {
+        clearTimeout(clientData.initTimer);
+        clientData.initTimer = undefined;
+    }
+}
+
 function sessionDirForUser(userId: string) {
     return join(SESSION_BASE_DIR, `session-user-${userId}`);
 }
@@ -135,7 +154,11 @@ async function getOrCreateClient(userId: string): Promise<ClientData> {
                 '--disable-gpu'
             ],
             ...(BROWSER_EXECUTABLE_PATH ? { executablePath: BROWSER_EXECUTABLE_PATH } : {})
-        }
+        },
+        ...(WEB_VERSION ? {
+            webVersion: WEB_VERSION,
+            webVersionCache: { type: 'remote' as const, remotePath: WEB_VERSION_CACHE_URL }
+        } : {})
     });
 
     const clientData: ClientData = {
@@ -148,8 +171,18 @@ async function getOrCreateClient(userId: string): Promise<ClientData> {
 
     clients.set(userId, clientData);
 
+    // Watchdog: if the client never reaches QR/READY, recycle it so the next
+    // poll spins a fresh attempt instead of wedging in INITIALIZING forever.
+    clientData.initTimer = setTimeout(() => {
+        if (clientData.state === 'INITIALIZING' && !clientData.qr && !clientData.ready) {
+            console.error(`User ${userId} stuck INITIALIZING > ${INIT_TIMEOUT_MS}ms — recycling`);
+            destroyClient(userId).catch(console.error);
+        }
+    }, INIT_TIMEOUT_MS);
+
     client.on('qr', async (qr) => {
         clientData.state = 'QR_REQUIRED';
+        clearInitTimer(clientData); // progress made — QR is showable
         try {
             clientData.qr = await toDataURL(qr);
             console.log(`QR RECEIVED and converted for User ${userId}`);
@@ -162,18 +195,21 @@ async function getOrCreateClient(userId: string): Promise<ClientData> {
         clientData.state = 'AUTHENTICATED';
         clientData.qr = null;
         clientData.ready = true;
+        clearInitTimer(clientData);
         console.log(`Client is READY for User ${userId}`);
     });
 
     client.on('authenticated', () => {
         clientData.state = 'AUTHENTICATED';
         clientData.ready = false;
+        clearInitTimer(clientData);
         console.log(`AUTHENTICATED for User ${userId}`);
     });
 
     client.on('auth_failure', (msg) => {
         clientData.state = 'DISCONNECTED';
         clientData.ready = false;
+        clearInitTimer(clientData);
         console.error(`AUTHENTICATION FAILURE for User ${userId}`, msg);
     });
 
@@ -186,6 +222,7 @@ async function getOrCreateClient(userId: string): Promise<ClientData> {
 
     client.initialize().catch(async (err) => {
         console.error(`Initialization failed for user ${userId}:`, err.message || err);
+        clearInitTimer(clientData);
         // Clean up the failed client
         try { client.removeAllListeners(); } catch (_) {}
         try { await client.destroy(); } catch (_) {}
@@ -203,11 +240,12 @@ async function getOrCreateClient(userId: string): Promise<ClientData> {
     return clientData;
 }
 
-async function destroyClient(userId: string) {
+async function destroyClient(userId: string, clearSession: boolean = false) {
     const data = clients.get(userId);
     if (data && !data.isDestroying) {
         data.isDestroying = true;
-        console.log(`Destroying WhatsApp client for User: ${userId}`);
+        clearInitTimer(data);
+        console.log(`Destroying WhatsApp client for User: ${userId} (clearSession: ${clearSession})`);
         try {
             // Unregister listeners to prevent loops or double-destroys
             data.client.removeAllListeners();
@@ -216,7 +254,18 @@ async function destroyClient(userId: string) {
             console.error(`Error destroying client for ${userId}`, e);
         }
         clients.delete(userId);
-        // Session data is preserved on disk for auto-reconnect
+        // Session data is preserved on disk for auto-reconnect (unless clearing below).
+    }
+    // On explicit logout, wipe the persisted Chromium profile / WhatsApp session
+    // from disk — even if there was no live client in memory.
+    if (clearSession) {
+        const dir = sessionDirForUser(userId);
+        try {
+            rmSync(dir, { recursive: true, force: true });
+            console.log(`Cleared session dir for User: ${userId}`);
+        } catch (e) {
+            console.error(`Failed to clear session dir for ${userId}`, e);
+        }
     }
 }
 
@@ -250,6 +299,17 @@ app.get('/qr/:userId', async (c) => {
     return c.json({ qr: data.qr });
 });
 
+// Explicit per-user logout: disconnect the client and wipe the saved WhatsApp
+// session from disk so the next connect starts fresh with a new QR. Triggered by
+// the user-settings "Log out WhatsApp" button — NOT by app sign-out.
+app.post('/logout/:userId', async (c) => {
+    const userId = c.req.param('userId');
+    console.log(`Logout requested for User: ${userId}`);
+    await destroyClient(userId, true);
+    initializingClients.delete(userId);
+    return c.json({ success: true });
+});
+
 app.post('/send/:userId', async (c) => {
     const userId = c.req.param('userId');
     const { to, message, mediaUrl } = await c.req.json();

data/lib/whatsapp_notifier/session/qr_service.rb

@@ -20,28 +20,6 @@ module WhatsAppNotifier
         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/version.rb

@@ -1,4 +1,4 @@
 module WhatsAppNotifier
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 
 end

data/lib/whatsapp_notifier/web_adapter.rb

@@ -52,6 +52,13 @@ module WhatsAppNotifier
       }
     end
 
+    # Logs the user out of WhatsApp and clears their saved session on the service.
+    def logout(metadata: {})
+      user_id = user_id_from(metadata)
+      response = request(:post, "/logout/#{user_id}")
+      { success: response.fetch("success", false) }
+    end
+
     private
 
     def user_id_from(metadata)

data/lib/whatsapp_notifier.rb

@@ -62,6 +62,10 @@ module WhatsAppNotifier
       client.connection_status(provider: provider, metadata: metadata)
     end
 
+    def logout(provider: nil, metadata: {})
+      client.logout(provider: provider, metadata: metadata)
+    end
+
   end
 end
 

data/spec/client_spec.rb

@@ -49,4 +49,21 @@ RSpec.describe WhatsAppNotifier::Client do
       expect(status).to include(state: "QR_REQUIRED")
     end
   end
+
+  it "delegates logout to the provider" do
+    Dir.mktmpdir do |dir|
+      config.provider = :web_automation
+      config.web_automation_enabled = true
+      config.web_session_path = File.join(dir, "session.json")
+      config.web_adapter = double(
+        send_message: { success: true, session: {} },
+        fetch_qr_code: "qr",
+        connection_status: { state: "AUTHENTICATED", authenticated: true },
+        logout: { success: true }
+      )
+      client = described_class.new(configuration: config)
+
+      expect(client.logout(provider: :web_automation, metadata: { user_id: 1 })).to eq(success: true)
+    end
+  end
 end

data/spec/jobs/send_message_job_spec.rb

@@ -24,13 +24,14 @@ RSpec.describe WhatsAppNotifier::Jobs::SendMessageJob do
     expect(result).to be_success
   end
 
-  it "raises when perform_later has no active job base" do
-    hide_const("ActiveJob")
-    expect { described_class.perform_later("JobNotification", to: "+1") }.to raise_error(LoadError)
+  it "falls back to synchronous delivery when ActiveJob is unavailable" do
+    # ActiveJob is not a gem dependency, so the sync-fallback class is the one
+    # that loads; perform_later runs perform_now rather than raising.
+    result = described_class.perform_later("JobNotification", to: "+1")
+    expect(result).to be_success
   end
 
-  it "allows perform_later when active job base is present" do
-    stub_const("ActiveJob::Base", Class.new)
+  it "allows perform_later without raising" do
     expect { described_class.perform_later("JobNotification", to: "+1") }.not_to raise_error
   end
 end

data/spec/notification_spec.rb

@@ -30,14 +30,19 @@ RSpec.describe WhatsAppNotifier::Notification do
     expect(result).to be_success
   end
 
-  it "supports deliver_later when active job exists" do
-    stub_const("ActiveJob::Base", Class.new)
+  it "supports deliver_later" do
     expect { TestNotification.deliver_later(params: { name: "Neha" }) }.not_to raise_error
   end
 
-  it "raises for deliver_later without active job" do
-    hide_const("ActiveJob")
-    expect { TestNotification.deliver_later(params: { name: "Neha" }) }.to raise_error(LoadError)
+  it "falls back to synchronous delivery for deliver_later without active job" do
+    # No ActiveJob dependency → deliver_later runs the job synchronously.
+    result = TestNotification.deliver_later(params: { name: "Neha" })
+    expect(result).to be_success
+  end
+
+  it "supports instance-level deliver_later" do
+    result = TestNotification.with(params: { name: "Neha" }).deliver_later
+    expect(result).to be_success
   end
 
   it "raises when recipient is missing" do

data/spec/providers/web_automation_spec.rb

@@ -106,4 +106,34 @@ RSpec.describe WhatsAppNotifier::Providers::WebAutomation do
       expect(adapter).to have_received(:send_message).with(payload: hash_including(metadata: { user_id: "user-b" }), session: {}).once
     end
   end
+
+  it "logs out via adapter when enabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {}, logout: { success: true })
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect(provider.logout(metadata: { user_id: 1 })).to eq(success: true)
+    end
+  end
+
+  it "raises on logout when provider disabled" do
+    Dir.mktmpdir do |dir|
+      adapter = double(fetch_qr_code: "qr", connection_status: {}, logout: { success: true })
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter, enabled: false)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.logout }.to raise_error(WhatsAppNotifier::ConfigurationError, /disabled/)
+    end
+  end
+
+  it "raises for missing adapter logout method" do
+    Dir.mktmpdir do |dir|
+      adapter = Object.new
+      config = build_config(path: File.join(dir, "session.json"), adapter: adapter)
+      provider = described_class.new(configuration: config)
+
+      expect { provider.logout }.to raise_error(WhatsAppNotifier::ConfigurationError, /web_adapter/)
+    end
+  end
 end

data/spec/session/qr_service_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe WhatsAppNotifier::Session::QrService do
     end
   end
 
-  it "caches qr code per user_id when metadata is provided" do
+  it "fetches a fresh qr on every call (codes expire, so no caching) and passes metadata" do
     Dir.mktmpdir do |dir|
       store = WhatsAppNotifier::Session::Store.new(path: File.join(dir, "s.json"))
       adapter = double
@@ -20,10 +20,9 @@ RSpec.describe WhatsAppNotifier::Session::QrService do
       service = described_class.new(store: store, adapter: adapter)
 
       expect(service.qr_code(metadata: { user_id: 1 })).to eq("qr-user-1")
-      expect(service.qr_code(metadata: { user_id: 1 })).to eq("qr-user-1")
-      expect(service.qr_code(metadata: { user_id: 2 })).to eq("qr-user-2")
+      expect(service.qr_code(metadata: { user_id: 1 })).to eq("qr-user-2")
 
-      expect(adapter).to have_received(:fetch_qr_code).twice
+      expect(adapter).to have_received(:fetch_qr_code).with(metadata: { user_id: 1 }).twice
     end
   end
 

data/spec/web_adapter_spec.rb

@@ -52,4 +52,26 @@ RSpec.describe WhatsAppNotifier::WebAdapter do
     expect(adapter.fetch_qr_code(metadata: {})).to be_nil
     expect { adapter.connection_status(metadata: {}) }.to raise_error(/raw-error/)
   end
+
+  it "logs out via the service" do
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: { "success" => true }))
+
+    expect(adapter.logout(metadata: { user_id: "u-1" })).to eq(success: true)
+  end
+
+  it "defaults logout success to false when the service omits it" do
+    allow(Net::HTTP).to receive(:start).and_return(http_success(body: {}))
+
+    expect(adapter.logout(metadata: {})).to eq(success: false)
+  end
+
+  it "executes the request inside the Net::HTTP block" do
+    fake_http = instance_double(Net::HTTP)
+    allow(fake_http).to receive(:request).and_return(http_success(body: { "qr" => "data:image/png;base64,x" }))
+    # Invoke the block so the real request path runs (other specs stub it away).
+    allow(Net::HTTP).to receive(:start) { |*_args, &blk| blk.call(fake_http) }
+
+    expect(adapter.fetch_qr_code(metadata: { user_id: 1 })).to eq("data:image/png;base64,x")
+    expect(fake_http).to have_received(:request)
+  end
 end

data/spec/whatsapp_notifier_spec.rb

@@ -93,11 +93,13 @@ RSpec.describe WhatsAppNotifier do
     allow(fake_client).to receive(:deliver_bulk).and_return(total: 0, success: 0, failed: 0, results: [])
     allow(fake_client).to receive(:scan_qr).and_return("qr-code")
     allow(fake_client).to receive(:connection_status).and_return(state: "QR_REQUIRED")
+    allow(fake_client).to receive(:logout).and_return(success: true)
     described_class.instance_variable_set(:@client, fake_client)
 
     expect(described_class.deliver_bulk([], provider: :web_automation)[:total]).to eq(0)
     expect(described_class.scan_qr(provider: :web_automation, metadata: { user_id: 1 })).to eq("qr-code")
     expect(described_class.connection_status(provider: :web_automation, metadata: { user_id: 1 })).to include(state: "QR_REQUIRED")
+    expect(described_class.logout(provider: :web_automation, metadata: { user_id: 1 })).to eq(success: true)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whatsapp_notifier
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kshitiz Sinha