coffeeinabit 0.0.5 → 0.0.7

package/linkedin_automation.js

@@ -44,6 +44,7 @@ export class LinkedInAutomation {
   }
 
   async saveLinkedInSession() {
+    console.warn('[LinkedInAutomation] saveLinkedInSession is deprecated - using persistent context instead');
     try {
       if (!this.context || !this.page) {
         console.error('[LinkedInAutomation] Cannot save session - no context or page');
@@ -91,6 +92,7 @@ export class LinkedInAutomation {
   }
 
   async loadLinkedInSession() {
+    console.warn('[LinkedInAutomation] loadLinkedInSession is deprecated - using persistent context instead');
     try {
       const sessionPath = this.getLinkedInSessionPath();
       
@@ -130,6 +132,7 @@ export class LinkedInAutomation {
   }
 
   async restoreLocalStorage() {
+    console.warn('[LinkedInAutomation] restoreLocalStorage is deprecated - using persistent context instead');
     try {
       const sessionPath = this.getLinkedInSessionPath();
       
@@ -322,8 +325,7 @@ export class LinkedInAutomation {
             if (secondCheck.includes('/feed')) {
               console.log('[LinkedInAutomation] Second check confirmed - still on /feed/');
               
-              console.log('[LinkedInAutomation] Saving LinkedIn session for future use...');
-              await this.saveLinkedInSession();
+              console.log('[LinkedInAutomation] Session will be persisted automatically by launchPersistentContext...');
               
               this.status = 'linkedin_logged_in';
               this.emitStatus();
@@ -384,10 +386,6 @@ export class LinkedInAutomation {
       if (this.context) {
         await this.context.close();
         this.context = null;
-      }
-
-      if (this.browser) {
-        await this.browser.close();
         this.browser = null;
       }
 
@@ -696,39 +694,108 @@ export class LinkedInAutomation {
   }
 
   async launchBrowserAndLogin() {
-    console.log('[LinkedInAutomation] Launching Firefox for LinkedIn login...');
+    console.log('[LinkedInAutomation] Launching Firefox with persistent context for LinkedIn login...');
+    
+    this.userEmail = this._currentUserEmail || 'default_user';
+    const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
+    const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
     
-    this.browser = await firefox.launch({ headless: this.headless || false });
+    console.log('[LinkedInAutomation] User data path:', userDataPath);
+
+    if (!fs.existsSync(userDataPath)) {
+      fs.mkdirSync(userDataPath, { recursive: true });
+      console.log('[LinkedInAutomation] Created user data directory:', userDataPath);
+    }
 
-    this.context = await this.browser.newContext({
+    const launchOptions = {
+      headless: this.headless || false,
       viewport: null,
       ignoreHTTPSErrors: true
-    });
+    };
+
+    this.context = await firefox.launchPersistentContext(userDataPath, launchOptions);
 
+    console.log('[LinkedInAutomation] Persistent context launched successfully');
+
+    this.browser = this.context;
+    
     await this.enablePerformanceMode();
     this.page = await this.context.newPage();
 
-    const sessionLoaded = await this.loadLinkedInSession();
+    console.log('[LinkedInAutomation] Checking if user is already authenticated...');
     
-    if (sessionLoaded) {
-      console.log('[LinkedInAutomation] Saved session loaded, checking if still authenticated...');
-      await this.checkAndVerifySession();
-    } else {
-      console.log('[LinkedInAutomation] No saved session, starting fresh login...');
+    const isAuthenticated = await this.checkAndVerifySession();
+    
+    if (!isAuthenticated) {
+      console.log('[LinkedInAutomation] Not authenticated, starting fresh login...');
       await this.startLinkedInLogin();
     }
   }
 
+  async updateBrowserVisibility(keepBrowser) {
+    if (!this.browser || !this.isRunning) {
+      console.log('[LinkedInAutomation] Browser not running, cannot update visibility');
+      return;
+    }
+
+    try {
+      const newHeadless = !keepBrowser;
+      
+      if (this.headless === newHeadless) {
+        console.log('[LinkedInAutomation] Browser visibility already matches setting');
+        return;
+      }
+
+      console.log(`[LinkedInAutomation] Updating browser visibility: ${keepBrowser ? 'visible' : 'headless'}`);
+      
+      const currentUrl = this.page.url();
+      const currentTitle = await this.page.title();
+      const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
+      const userDataPath = path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}`);
+      
+      await this.context.close();
+      
+      this.headless = newHeadless;
+      
+      this.context = await firefox.launchPersistentContext(userDataPath, {
+        headless: this.headless,
+        viewport: null,
+        ignoreHTTPSErrors: true
+      });
+
+      this.browser = this.context;
+
+      await this.enablePerformanceMode();
+      this.page = await this.context.newPage();
+      
+      await this.page.goto(currentUrl, { 
+        waitUntil: 'domcontentloaded',
+        timeout: 30000
+      });
+
+      this.setupPageListeners();
+      
+      console.log('[LinkedInAutomation] Browser visibility updated successfully');
+      
+      this.io.emit('automation_status', { 
+        status: 'running',
+        message: `Browser is now ${keepBrowser ? 'visible' : 'running in headless mode'}`
+      });
+      
+    } catch (error) {
+      console.error('[LinkedInAutomation] Failed to update browser visibility:', error);
+      throw error;
+    }
+  }
+
   async checkAndVerifySession() {
     try {
-      console.log('[LinkedInAutomation] Navigating to LinkedIn feed to verify session...');
+      console.log('[LinkedInAutomation] Navigating to LinkedIn feed to verify persistent session...');
       await this.page.goto('https://www.linkedin.com/feed/', { 
         waitUntil: 'domcontentloaded',
         timeout: 30000
       });
 
-      await this.restoreLocalStorage();
-
       await new Promise(resolve => setTimeout(resolve, 3000));
 
       let verifyAttempts = 0;
@@ -739,7 +806,7 @@ export class LinkedInAutomation {
         console.log(`[LinkedInAutomation] Verification attempt ${verifyAttempts + 1}/${maxVerifyAttempts}, URL: ${this.currentUrl}`);
 
         if (this.currentUrl.includes('/feed')) {
-          console.log('[LinkedInAutomation] Session verified! Already logged in.');
+          console.log('[LinkedInAutomation] Session verified! Already logged in via persistent context.');
           this.status = 'linkedin_logged_in';
           this.emitStatus();
           

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "CoffeeInABit App",
   "main": "server.js",
   "type": "module",
-  "keywords": ["automation", "linkedin", "windows", "playwright"],
+  "keywords": [
+    "automation",
+    "linkedin",
+    "windows",
+    "playwright"
+  ],
   "author": "Azam Alamov <azam.alamov@icloud.com>",
   "license": "MIT",
   "bin": {

package/public/dashboard.html

@@ -205,16 +205,40 @@
             }
         }
 
-        function toggleKeepBrowser() {
+        async function toggleKeepBrowser() {
             const keepBrowserToggle = document.getElementById('keepBrowserToggle');
             const isKeepBrowser = keepBrowserToggle.checked;
             
-            if (isKeepBrowser) {
-                localStorage.setItem('keepBrowser', 'true');
-                showAlert('info', 'Browser will be visible when automation starts');
-            } else {
-                localStorage.setItem('keepBrowser', 'false');
-                showAlert('info', 'Browser will run in headless mode');
+            localStorage.setItem('keepBrowser', isKeepBrowser.toString());
+            
+            try {
+                const response = await fetch('/api/automation/settings', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        keepBrowser: isKeepBrowser
+                    })
+                });
+
+                const data = await response.json();
+                
+                if (data.success) {
+                    if (isKeepBrowser) {
+                        showAlert('success', 'Browser is now visible');
+                    } else {
+                        showAlert('success', 'Browser is now running in headless mode');
+                    }
+                } else {
+                    showAlert('error', data.error || 'Failed to update browser setting');
+                    keepBrowserToggle.checked = !isKeepBrowser;
+                    localStorage.setItem('keepBrowser', (!isKeepBrowser).toString());
+                }
+            } catch (error) {
+                showAlert('error', 'Error updating browser setting: ' + error.message);
+                keepBrowserToggle.checked = !isKeepBrowser;
+                localStorage.setItem('keepBrowser', (!isKeepBrowser).toString());
             }
         }
 

package/server.js

@@ -173,6 +173,26 @@ app.get('/api/automation/status', (req, res) => {
   res.json(linkedinAutomation.getStatus());
 });
 
+app.post('/api/automation/settings', async (req, res) => {
+  if (!cloudAuth.isAuthenticated(req.session)) {
+    return res.status(401).json({ error: 'Authentication required' });
+  }
+
+  try {
+    const { keepBrowser } = req.body;
+    
+    if (typeof keepBrowser !== 'boolean') {
+      return res.status(400).json({ error: 'keepBrowser must be a boolean' });
+    }
+
+    await linkedinAutomation.updateBrowserVisibility(keepBrowser);
+    res.json({ success: true, message: 'Browser visibility setting updated' });
+  } catch (error) {
+    console.error('[Server] Failed to update browser settings:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 io.on('connection', (socket) => {
   console.log('[Server] Client connected:', socket.id);
   

package/tools/get_daily_linkedin_connections.js

@@ -25,38 +25,43 @@ export async function executeGetDailyLinkedInConnections(page, action) {
   });
   
   const now = Date.now();
-  const newConnections = await page.evaluate(({ lastCheckTimestamp, now }) => {
-    function parseConnectionDate(str) {
-      if (!str) return null;
-      const match = str.match(/Connected on (.+)/i);
-      if (!match) return null;
-      const dateStr = match[1].trim();
-      try {
-        const timestamp = new Date(dateStr).getTime();
-        return isNaN(timestamp) ? null : timestamp;
-      } catch (e) {
-        return null;
+  let allConnectionsMap = new Map();
+  let shouldStopScrolling = false;
+  let noScrollAttempts = 0;
+  const maxNoScrollAttempts = 2;
+  
+  while (!shouldStopScrolling) {
+    const currentConnections = await page.evaluate(() => {
+      function parseConnectionDate(str) {
+        if (!str) return null;
+        const match = str.match(/Connected on (.+)/i);
+        if (!match) return null;
+        const dateStr = match[1].trim();
+        try {
+          const timestamp = new Date(dateStr).getTime();
+          return isNaN(timestamp) ? null : timestamp;
+        } catch (e) {
+          return null;
+        }
       }
-    }
-    
-    const connections = [];
-    const allParagraphs = document.querySelectorAll('p');
-    
-    allParagraphs.forEach(p => {
-      const text = p.textContent.trim();
-      if (text.startsWith('Connected on')) {
-        const parentDiv = p.parentElement;
-        if (parentDiv) {
-          const profileLink = parentDiv.querySelector('a[href*="/in/"]');
-          if (profileLink) {
-            const href = profileLink.getAttribute('href');
-            const usernameMatch = href.match(/\/in\/([^/?]+)/);
-            if (usernameMatch) {
-              const username = usernameMatch[1];
-              const connectionDate = text;
-              const connectionTimestamp = parseConnectionDate(connectionDate);
-              
-              if (!lastCheckTimestamp || (connectionTimestamp && connectionTimestamp >= lastCheckTimestamp)) {
+      
+      const connections = [];
+      const allParagraphs = document.querySelectorAll('p');
+      
+      allParagraphs.forEach(p => {
+        const text = p.textContent.trim();
+        if (text.startsWith('Connected on')) {
+          const parentDiv = p.parentElement;
+          if (parentDiv) {
+            const profileLink = parentDiv.querySelector('a[href*="/in/"]');
+            if (profileLink) {
+              const href = profileLink.getAttribute('href');
+              const usernameMatch = href.match(/\/in\/([^/?]+)/);
+              if (usernameMatch) {
+                const username = usernameMatch[1];
+                const connectionDate = text;
+                const connectionTimestamp = parseConnectionDate(connectionDate);
+                
                 connections.push({
                   username: username,
                   connectionDate: connectionDate,
@@ -66,11 +71,121 @@ export async function executeGetDailyLinkedInConnections(page, action) {
             }
           }
         }
+      });
+      
+      return connections;
+    });
+    
+    currentConnections.forEach(conn => {
+      allConnectionsMap.set(conn.username, conn);
+    });
+    
+    console.log(`[get_daily_linkedin_connections] Current page connections: ${currentConnections.length}, Total unique: ${allConnectionsMap.size}`);
+    
+    if (lastCheckTimestamp && currentConnections.length > 0) {
+      const oldestConnection = currentConnections.reduce((oldest, current) => {
+        if (!oldest.connectionTimestamp) return current;
+        if (!current.connectionTimestamp) return oldest;
+        return current.connectionTimestamp < oldest.connectionTimestamp ? current : oldest;
+      });
+      
+      if (oldestConnection.connectionTimestamp && oldestConnection.connectionTimestamp < lastCheckTimestamp) {
+        console.log('[get_daily_linkedin_connections] Reached connections older than last check, stopping');
+        shouldStopScrolling = true;
+        break;
       }
+    }
+    
+    const scrollInfoBefore = await page.evaluate(() => {
+      const main = document.querySelector('main');
+      if (main) {
+        return {
+          scrollTop: main.scrollTop,
+          scrollHeight: main.scrollHeight,
+          clientHeight: main.clientHeight
+        };
+      }
+      return {
+        scrollTop: window.pageYOffset || document.documentElement.scrollTop,
+        scrollHeight: document.documentElement.scrollHeight,
+        clientHeight: window.innerHeight
+      };
     });
     
-    return connections;
-  }, { lastCheckTimestamp, now });
+    console.log(`[get_daily_linkedin_connections] Before scroll - Top: ${scrollInfoBefore.scrollTop}px, Height: ${scrollInfoBefore.scrollHeight}px`);
+    
+    try {
+      console.log('[get_daily_linkedin_connections] Scrolling main element...');
+      
+      const mainElement = await page.locator('main').first();
+      const containerExists = await mainElement.count();
+      
+      if (containerExists > 0) {
+        await mainElement.evaluate(el => {
+          console.log('Main element found, scrolling...');
+          console.log('Main scrollHeight:', el.scrollHeight);
+          console.log('Main clientHeight:', el.clientHeight);
+          console.log('Main scrollTop before:', el.scrollTop);
+          
+          el.scrollBy({ top: 2000, behavior: 'smooth' });
+          
+          console.log('Main scrollTop after:', el.scrollTop);
+        });
+        
+        console.log('[get_daily_linkedin_connections] Scroll completed');
+      } else {
+        console.log('[get_daily_linkedin_connections] Main element not found');
+      }
+      console.log('[get_daily_linkedin_connections] Waiting for content to load...');
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    } catch (e) {
+      console.log(`[get_daily_linkedin_connections] Scroll failed: ${e.message}`);
+      console.log('Stack trace:', e.stack);
+    }
+    
+    const scrollInfoAfter = await page.evaluate(() => {
+      const main = document.querySelector('main');
+      if (main) {
+        return {
+          scrollTop: main.scrollTop,
+          scrollHeight: main.scrollHeight,
+          clientHeight: main.clientHeight
+        };
+      }
+      return {
+        scrollTop: window.pageYOffset || document.documentElement.scrollTop,
+        scrollHeight: document.documentElement.scrollHeight,
+        clientHeight: window.innerHeight
+      };
+    });
+    
+    console.log(`[get_daily_linkedin_connections] After scroll - Top: ${scrollInfoAfter.scrollTop}px, Height: ${scrollInfoAfter.scrollHeight}px`);
+    
+    const scrolled = scrollInfoAfter.scrollTop > scrollInfoBefore.scrollTop;
+    const heightIncreased = scrollInfoAfter.scrollHeight > scrollInfoBefore.scrollHeight;
+    
+    if (scrolled || heightIncreased) {
+      console.log('[get_daily_linkedin_connections] Page scrolled or expanded, continuing...');
+      noScrollAttempts = 0; 
+    } else {
+      noScrollAttempts++;
+      console.log(`[get_daily_linkedin_connections] No scroll detected (attempt ${noScrollAttempts}/${maxNoScrollAttempts})`);
+      
+      if (noScrollAttempts < maxNoScrollAttempts) {
+        console.log('[get_daily_linkedin_connections] Waiting 5 seconds and trying again...');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      } else {
+        console.log('[get_daily_linkedin_connections] Max attempts reached, stopping scroll');
+        shouldStopScrolling = true;
+      }
+    }
+  }
+  
+  const allConnections = Array.from(allConnectionsMap.values());
+  
+  const newConnections = allConnections.filter(conn => {
+    return !lastCheckTimestamp || (conn.connectionTimestamp && conn.connectionTimestamp >= lastCheckTimestamp);
+  });
   
   return {
     action: 'get_daily_linkedin_connections',

package/tools/get_linkedin_search_results.js

@@ -38,19 +38,15 @@ export async function executeLinkedInSearch(page, action) {
     
     try {
       title = await page.title();
-      const listItems = await page.locator('ul[role="list"] li').all();
-      
-      if (listItems.length > 0) {
-        const firstItem = listItems[0];
-        const firstItemHTML = await firstItem.innerHTML().catch(() => '');
-        console.log('[LinkedInSearch] First item HTML structure:', firstItemHTML.substring(0, 500));
-      } else {
-        console.log('[LinkedInSearch] No list items found');
-        break;
-      }
-      
+
+      // LinkedIn’s new structure
+      const htmlContent = await page.content();
+    
+      // Look for cards directly by anchor structure
+      const hasCards = await page.locator('a[href*="/in/"]').count();
+      console.log(`[LinkedInSearch] Found ${hasCards} profile cards`);
+    
       const pageSearchResults = await parseLinkedInSearchResultsFromHTML(htmlContent);
-      
       pageResults = pageSearchResults;
     } catch (error) {
       pageResults = [];
@@ -65,7 +61,6 @@ export async function executeLinkedInSearch(page, action) {
     
     try {
       await page.goto(nextUrl, {
-        waitUntil: 'load',
         timeout: Math.floor(Math.random() * 20000) + 10000
       });
       navigationSuccess = true;
@@ -90,52 +85,57 @@ export async function executeLinkedInSearch(page, action) {
 }
 
 async function parseLinkedInSearchResultsFromHTML(htmlContent) {
+  const results = [];
   try {
-    const results = [];
-    
-    const listItemPattern = /<li[^>]*>([\s\S]*?)<\/li>/gi;
-    const linkPattern = /<a[^>]*href="([^"]*\/in\/[^"]*)"[^>]*>/gi;
-    
-    let listItemMatch;
-    
-    while ((listItemMatch = listItemPattern.exec(htmlContent)) !== null) {
-      const listItemHtml = listItemMatch[1];
-      
-      const linkMatches = [];
-      let linkMatch;
-      
-      while ((linkMatch = linkPattern.exec(listItemHtml)) !== null) {
-        linkMatches.push(linkMatch[1]);
-      }
-      
-      if (linkMatches.length > 0) {
-        const href = linkMatches[0];
-        let username = '';
-        
-        if (href) {
-          const usernameMatch = href.match(/\/in\/([^/?]+)/);
-          if (usernameMatch) {
-            username = usernameMatch[1];
-          }
-        }
-        
-        const textContent = listItemHtml
-          .replace(/<[^>]*>/g, ' ')
-          .replace(/\s+/g, ' ')
-          .trim();
-        
-        results.push({
-          link: href,
-          username: username,
-          item: textContent
-        });
-      }
+    const cardPattern = /<a[^>]+href="([^"]*linkedin\.com\/in\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+
+    let match;
+    const seen = new Set();
+
+    while ((match = cardPattern.exec(htmlContent)) !== null) {
+      const [fullMatch, href, contentHtml] = match;
+      if (seen.has(href)) continue; // avoid duplicates
+      seen.add(href);
+
+      const usernameMatch = href.match(/\/in\/([^/?#]+)/);
+      const username = usernameMatch ? usernameMatch[1] : "";
+
+      // Extract name
+      const nameMatch = contentHtml.match(/>([^<>]{2,50})<\/span>/);
+      const name = nameMatch ? nameMatch[1].trim() : "";
+
+      // Extract headline (title, role)
+      const headlineMatch = contentHtml.match(/<div[^>]*>\s*([^<]{5,100})<\/div>/);
+      const headline = headlineMatch ? headlineMatch[1].trim() : "";
+
+      // Extract connection level
+      const connectionMatch = contentHtml.match(/\b(1st|2nd|3rd\+)\b/);
+      const connectionLevel = connectionMatch ? connectionMatch[1] : "";
+
+      // Extract location
+      const locationMatch = htmlContent
+        .slice(cardPattern.lastIndex, cardPattern.lastIndex + 800)
+        .match(/([A-Z][a-z]+(?:, [A-Z]{2})?)(?=<)/);
+      const location = locationMatch ? locationMatch[1].trim() : "";
+
+      // Unique ID (message ID-like)
+      const uniqueIdMatch = fullMatch.match(/data-view-tracking-scope=.*?contentTrackingId&quot;:&quot;([^&]+)&quot;/);
+      const uniqueId = uniqueIdMatch ? uniqueIdMatch[1] : "";
+
+      results.push({
+        username,
+        link: href,
+        name,
+        headline,
+        location,
+        connectionLevel,
+        uniqueId,
+      });
     }
-    
+
     return results;
-    
   } catch (error) {
-    console.error('[LinkedInSearch] Error parsing search results:', error);
+    console.error("[LinkedInSearch] Parsing failed:", error);
     return [];
   }
-}
+}

package/tools/get_messages.js

@@ -12,6 +12,23 @@ export async function executeGetMessages(page, action) {
   });
   
   await page.waitForLoadState('domcontentloaded');
+  await page.waitForLoadState('networkidle');
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  await page.evaluate(() => { window.scrollTo(0, 0); });
+  await new Promise(resolve => setTimeout(resolve, 500));
+  await page.evaluate(() => { window.scrollTo(0, 300); });
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  try {
+    await page.waitForSelector('button[aria-label^="Message"], main button.artdeco-button--primary', { 
+      timeout: 5000,
+      state: 'attached'
+    });
+  } catch (error) {
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, 500));
   
   const pendingButton = await getButtonByText(page, 'Pending', true);
   if (pendingButton) {
@@ -22,20 +39,204 @@ export async function executeGetMessages(page, action) {
     };
   }
   
-  const clicked = await page.evaluate(() => {
-    const buttons = Array.from(document.querySelectorAll('.artdeco-button--primary'));
-    console.log('found buttons: ', buttons);
-    const messageBtn = buttons.find(btn =>
-      btn.textContent.includes('Message') && btn.offsetParent !== null
-    );
-    if (messageBtn) {
-      messageBtn.click();
+  let clicked = false;
+  
+  const checkOverlayAppeared = async (page) => {
+    const overlaySelectors = [
+      '.msg-overlay-conversation-bubble__content-wrapper',
+      '.msg-overlay',
+      '[class*="msg-overlay"]',
+      '[class*="conversation-bubble"]'
+    ];
+    
+    for (let attempt = 0; attempt < 15; attempt++) {
+      for (const selector of overlaySelectors) {
+        try {
+          const count = await page.locator(selector).count();
+          if (count > 0) {
+            return true;
+          }
+        } catch (error) {
+        }
+      }
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    try {
+      await page.waitForSelector('.msg-overlay-conversation-bubble__content-wrapper', { 
+        timeout: 5000,
+        state: 'attached'
+      });
       return true;
+    } catch (error) {
     }
-    console.log('no messageBtn found');
+    
     return false;
-  });
+  };
+  
+  const clickStrategies = [
+    async () => {
+      try {
+        const buttons = await page.locator('button[aria-label^="Message"]').all();
+        for (const btn of buttons) {
+          const isVisible = await btn.isVisible().catch(() => false);
+          const ariaLabel = await btn.getAttribute('aria-label').catch(() => '');
+          if (isVisible && ariaLabel && ariaLabel.startsWith('Message')) {
+            await btn.scrollIntoViewIfNeeded();
+            await new Promise(resolve => setTimeout(resolve, 500));
+            await btn.click({ timeout: 5000, force: false });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return await checkOverlayAppeared(page);
+          }
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const buttons = await page.locator('main button[aria-label^="Message"]').all();
+        for (const btn of buttons) {
+          const isVisible = await btn.isVisible().catch(() => false);
+          if (isVisible) {
+            await btn.scrollIntoViewIfNeeded();
+            await new Promise(resolve => setTimeout(resolve, 300));
+            await btn.click({ timeout: 5000, force: false });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            return await checkOverlayAppeared(page);
+          }
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const buttons = await page.locator('main button.artdeco-button--primary').all();
+        for (const btn of buttons) {
+          try {
+            const text = await btn.textContent().catch(() => '');
+            const ariaLabel = await btn.getAttribute('aria-label').catch(() => '');
+            const isVisible = await btn.isVisible().catch(() => false);
+            
+            if (isVisible && text && text.trim().includes('Message') && 
+                (!text.includes('Pending')) &&
+                (!ariaLabel || !ariaLabel.includes('Pending'))) {
+              await btn.scrollIntoViewIfNeeded();
+              await new Promise(resolve => setTimeout(resolve, 300));
+              await btn.click({ timeout: 5000, force: false });
+              await new Promise(resolve => setTimeout(resolve, 1000));
+              return await checkOverlayAppeared(page);
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const allButtons = await page.locator('main button').all();
+        for (const btn of allButtons) {
+          try {
+            const text = await btn.textContent().catch(() => '');
+            const ariaLabel = await btn.getAttribute('aria-label').catch(() => '');
+            const isVisible = await btn.isVisible().catch(() => false);
+            
+            if (isVisible && ((ariaLabel && ariaLabel.startsWith('Message')) || 
+                (text && text.includes('Message') && !text.includes('Pending')))) {
+              await btn.scrollIntoViewIfNeeded();
+              await new Promise(resolve => setTimeout(resolve, 300));
+              await btn.click({ timeout: 5000, force: false });
+              await new Promise(resolve => setTimeout(resolve, 1000));
+              return await checkOverlayAppeared(page);
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const buttonFound = await page.evaluate(() => {
+          const buttons = Array.from(document.querySelectorAll('button'));
+          for (const btn of buttons) {
+            const ariaLabel = btn.getAttribute('aria-label') || '';
+            const textContent = btn.textContent || '';
+            const isVisible = btn.offsetParent !== null && 
+                            window.getComputedStyle(btn).visibility !== 'hidden' &&
+                            window.getComputedStyle(btn).display !== 'none';
+            
+            if (isVisible && (ariaLabel.startsWith('Message') || 
+                (textContent.includes('Message') && !textContent.includes('Pending')))) {
+              const rect = btn.getBoundingClientRect();
+              if (rect.width > 0 && rect.height > 0) {
+                return {
+                  found: true,
+                  x: rect.left + rect.width / 2,
+                  y: rect.top + rect.height / 2
+                };
+              }
+            }
+          }
+          return { found: false };
+        });
+        
+        if (buttonFound.found) {
+          await page.mouse.click(buttonFound.x, buttonFound.y);
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return await checkOverlayAppeared(page);
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const messageBtn = await getButtonByText(page, 'Message', true);
+        if (messageBtn) {
+          await messageBtn.scrollIntoViewIfNeeded();
+          await new Promise(resolve => setTimeout(resolve, 300));
+          await messageBtn.click({ timeout: 5000, force: false });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return await checkOverlayAppeared(page);
+        }
+      } catch (error) {
+      }
+      return false;
+    },
+    async () => {
+      try {
+        const messageBtn = await getButtonByText(page, 'Message', false);
+        if (messageBtn) {
+          await messageBtn.scrollIntoViewIfNeeded();
+          await new Promise(resolve => setTimeout(resolve, 300));
+          await messageBtn.click({ timeout: 5000, force: false });
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return await checkOverlayAppeared(page);
+        }
+      } catch (error) {
+      }
+      return false;
+    }
+  ];
   
+  for (const strategy of clickStrategies) {
+    try {
+      clicked = await strategy();
+      if (clicked) {
+        break;
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+
   if (!clicked) {
     return {
       action: 'get_messages',
@@ -44,18 +245,75 @@ export async function executeGetMessages(page, action) {
     };
   }
   
-  await page.waitForSelector('.msg-overlay-conversation-bubble__content-wrapper', { timeout: 10000 });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+  try {
+    await page.waitForSelector('.msg-overlay-conversation-bubble__content-wrapper', { timeout: 15000 });
+  } catch (error) {
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const overlayExists = await page.locator('.msg-overlay-conversation-bubble__content-wrapper').count();
+    if (overlayExists === 0) {
+      return {
+        action: 'get_messages',
+        result: { status: 'error', message: `Clicked Message button but overlay did not appear for ${username}` },
+        status: 'failed'
+      };
+    }
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 1000));
   
   await page.evaluate(() => {
-    const wrapper = document.querySelector('.msg-overlay-conversation-bubble__content-wrapper');
-    if (wrapper) {
-      wrapper.scrollTo(0, 0);
+    const messageList = document.querySelector('.msg-s-message-list');
+    if (messageList) {
+      messageList.scrollTop = 0;
     }
   });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 5000) + 500));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  let previousScrollHeight = 0;
+  let scrollAttempts = 0;
+  const maxScrollAttempts = 10;
+  
+  while (scrollAttempts < maxScrollAttempts) {
+    const scrollResult = await page.evaluate(() => {
+      const messageList = document.querySelector('.msg-s-message-list');
+      if (!messageList) return { shouldContinue: false, scrollHeight: 0 };
+      
+      const currentScrollHeight = messageList.scrollHeight;
+      messageList.scrollTop = messageList.scrollHeight;
+      
+      return {
+        shouldContinue: true,
+        scrollHeight: currentScrollHeight,
+        scrollTop: messageList.scrollTop
+      };
+    });
+    
+    if (!scrollResult.shouldContinue) {
+      break;
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    
+    const newScrollHeight = await page.evaluate(() => {
+      const messageList = document.querySelector('.msg-s-message-list');
+      return messageList ? messageList.scrollHeight : 0;
+    });
+    
+    if (newScrollHeight === previousScrollHeight) {
+      break;
+    }
+    
+    previousScrollHeight = newScrollHeight;
+    scrollAttempts++;
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
   
   const content = await page.evaluate(() => {
+    const messageList = document.querySelector('.msg-s-message-list');
+    if (messageList) {
+      return messageList.innerText || '';
+    }
     const wrapper = document.querySelector('.msg-overlay-conversation-bubble__content-wrapper');
     return wrapper ? wrapper.innerText : '';
   });
@@ -68,24 +326,32 @@ export async function executeGetMessages(page, action) {
 }
 
 async function getButtonByText(page, text, inMain = false) {
-  let buttons = [];
-  if (inMain) {
-    buttons = await page.locator('main button').all();
-  } else {
-    buttons = await page.locator('button').all();
-  }
-  
-  for (const button of buttons) {
-    try {
-      const buttonText = await button.textContent();
-      if (buttonText && buttonText.includes(text)) {
-        const isVisible = await button.isVisible();
-        if (isVisible) {
-          return button;
+  try {
+    let buttons = [];
+    if (inMain) {
+      buttons = await page.locator('main button').all();
+    } else {
+      buttons = await page.locator('button').all();
+    }
+    
+    for (const button of buttons) {
+      try {
+        const buttonText = await button.textContent().catch(() => '');
+        const ariaLabel = await button.getAttribute('aria-label').catch(() => '');
+        const isVisible = await button.isVisible().catch(() => false);
+        
+        if (isVisible && ((buttonText && buttonText.trim().includes(text)) || 
+            (ariaLabel && ariaLabel.includes(text)))) {
+          const boundingBox = await button.boundingBox().catch(() => null);
+          if (boundingBox && boundingBox.width > 0 && boundingBox.height > 0) {
+            return button;
+          }
         }
+      } catch (error) {
+        continue;
       }
-    } catch (error) {
     }
+  } catch (error) {
   }
   
   return null;