coffeeinabit 0.0.11 → 0.0.13

package/tools/get_messages.js

@@ -1,15 +1,21 @@
 export async function executeGetMessages(page, action) {
+  console.log('[get_messages] Starting executeGetMessages');
   const username = action.parameters?.username || action.username;
   
+  console.log('[get_messages] Username:', username);
+  
   if (!username) {
+    console.error('[get_messages] Missing username');
     throw new Error('Missing username for get_messages');
   }
   
   const profileUrl = `https://www.linkedin.com/in/${username}`;
+  console.log('[get_messages] Navigating to profile:', profileUrl);
   await page.goto(profileUrl, {
     waitUntil: 'load',
     timeout: Math.floor(Math.random() * 20000) + 40000
   });
+  console.log('[get_messages] Page loaded, URL:', page.url());
   
   await page.waitForLoadState('domcontentloaded');
   await new Promise(resolve => setTimeout(resolve, 1000));
@@ -19,7 +25,10 @@ export async function executeGetMessages(page, action) {
   await new Promise(resolve => setTimeout(resolve, 500));
   await page.evaluate(() => { window.scrollTo(0, 300); });
   await new Promise(resolve => setTimeout(resolve, 1000));
-  
+
+  console.log('[get_messages] Closing all conversation bubbles');
+  await closeAllConversationBubbles(page);
+
   try {
     await page.waitForSelector('button[aria-label^="Message"], main button.artdeco-button--primary', { 
       timeout: 5000,
@@ -27,18 +36,21 @@ export async function executeGetMessages(page, action) {
     });
   } catch (error) {
   }
-  
+
   await new Promise(resolve => setTimeout(resolve, 500));
   
+  console.log('[get_messages] Checking for pending connection request');
   const pendingButton = await getButtonByText(page, 'Pending', true);
   if (pendingButton) {
+    console.log('[get_messages] Connection request is pending');
     return {
       action: 'get_messages',
       result: { status: 'connection_request_pending', message: `Connection request pending for ${username}. Not connected` },
       status: 'pending'
     };
   }
-  
+
+  console.log('[get_messages] Trying to find and click Message button');
   let clicked = false;
   
   const checkOverlayAppeared = async (page) => {
@@ -87,8 +99,8 @@ export async function executeGetMessages(page, action) {
         if (await btn.isVisible().catch(() => false)) {
           await btn.scrollIntoViewIfNeeded();
           await new Promise(resolve => setTimeout(resolve, 300));
-          await btn.click({ timeout: 5000, force: false });
-          await new Promise(resolve => setTimeout(resolve, 1000));
+          await btn.click({ timeout: 5000 });
+          await new Promise(resolve => setTimeout(resolve, 800));
           return await checkOverlayAppeared(page);
         }
       } catch (error) {}
@@ -100,8 +112,8 @@ export async function executeGetMessages(page, action) {
         if (await btn.isVisible().catch(() => false)) {
           await btn.scrollIntoViewIfNeeded();
           await new Promise(resolve => setTimeout(resolve, 300));
-          await btn.click({ timeout: 5000, force: false });
-          await new Promise(resolve => setTimeout(resolve, 1000));
+          await btn.click({ timeout: 5000 });
+          await new Promise(resolve => setTimeout(resolve, 800));
           return await checkOverlayAppeared(page);
         }
       } catch (error) {}
@@ -112,14 +124,13 @@ export async function executeGetMessages(page, action) {
         const classToken = 'DhBcSsKzUnyKdEOWwBJmWavDjlHFWuqygdMVO';
         const candidates = await page.locator(`button.artdeco-button--primary.${classToken}`).all();
         for (const btn of candidates.slice(0, 3)) {
-          const isVisible = await btn.isVisible().catch(() => false);
-          if (!isVisible) continue;
+          const v = await btn.isVisible().catch(() => false);
+          if (!v) continue;
           await btn.scrollIntoViewIfNeeded();
           await new Promise(resolve => setTimeout(resolve, 200));
-          await btn.click({ timeout: 5000, force: false });
+          await btn.click({ timeout: 5000 });
           await new Promise(resolve => setTimeout(resolve, 800));
-          const ok = await checkOverlayAppeared(page);
-          if (ok) return true;
+          if (await checkOverlayAppeared(page)) return true;
         }
       } catch (error) {}
       return false;
@@ -129,164 +140,34 @@ export async function executeGetMessages(page, action) {
         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();
+          if (!isVisible) continue;
+          await btn.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);
+          await btn.click({ timeout: 5000 });
+          await new Promise(resolve => setTimeout(resolve, 800));
+          if (await checkOverlayAppeared(page)) return true;
         }
-      } catch (error) {
-      }
+      } catch (error) {}
       return false;
     }
   ];
   
-  for (const strategy of clickStrategies) {
+  for (let i = 0; i < clickStrategies.length; i++) {
+    console.log('[get_messages] Trying strategy', i + 1);
     try {
-      clicked = await strategy();
+      clicked = await clickStrategies[i]();
       if (clicked) {
+        console.log('[get_messages] Strategy', i + 1, 'succeeded, conversation opened');
         break;
       }
     } catch (error) {
+      console.log('[get_messages] Strategy', i + 1, 'error:', error.message);
       continue;
     }
   }
 
   if (!clicked) {
+    console.error('[get_messages] Failed to open conversation - could not find Message button');
     return {
       action: 'get_messages',
       result: { status: 'not_connected', message: `Could not find Message button on ${username}'s profile. This usually means you are not connected with this user on LinkedIn. You can only retrieve messages from users who are in your connections.` },
@@ -294,89 +175,81 @@ export async function executeGetMessages(page, action) {
     };
   }
   
-  try {
-    await page.waitForSelector('.msg-s-message-list-container', { timeout: 15000 });
-  } catch (error) {
-    try {
-      await page.waitForSelector('.msg-overlay-conversation-bubble__content-wrapper', { timeout: 5000 });
-    } catch (e) {
-      return {
-        action: 'get_messages',
-        result: { status: 'error', message: `Clicked Message but no conversation view appeared for ${username}` },
-        status: 'failed'
-      };
-    }
-  }
+  console.log('[get_messages] Conversation opened successfully');
   
   await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 1000));
-  
-  await page.evaluate(() => {
-    const messageList = document.querySelector('.msg-s-message-list');
-    if (messageList) {
-      messageList.scrollTop = 0;
+
+  console.log('[get_messages] Looking for message input by aria-label');
+  const messageData = await page.evaluate(() => {
+    const messageInput = document.querySelector('[aria-label="Write a message…"]');
+    if (!messageInput) {
+      console.log('[get_messages] Message input not found');
+      return { found: false, content: '', items: [] };
     }
-  });
-  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;
+
+    console.log('[get_messages] Found message input, traversing up parent chain');
+    let currentElement = messageInput.parentElement;
+    let level = 0;
+    const maxLevels = 20;
+
+    while (currentElement && level < maxLevels) {
+      level++;
+      const hasMessageListContainer = currentElement.classList.contains('msg-s-message-list-container');
       
-      return {
-        shouldContinue: true,
-        scrollHeight: currentScrollHeight,
-        scrollTop: messageList.scrollTop
-      };
-    });
-    
-    if (!scrollResult.shouldContinue) {
-      break;
+      if (hasMessageListContainer) {
+        console.log('[get_messages] Found msg-s-message-list-container at level', level);
+        const content = currentElement.innerText || currentElement.textContent || '';
+        const ul = currentElement.querySelector('ul.msg-s-message-list-content');
+        const items = ul ? Array.from(ul.querySelectorAll('li')).map(li => (li.innerText || '').trim()).filter(Boolean) : [];
+        return { found: true, content: content.trim(), items: items };
+      }
+
+      currentElement = currentElement.parentElement;
     }
-    
-    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;
+
+    console.log('[get_messages] Reached max levels or no parent found, using last element');
+    if (currentElement) {
+      const content = currentElement.innerText || currentElement.textContent || '';
+      const ul = currentElement.querySelector('ul.msg-s-message-list-content');
+      const items = ul ? Array.from(ul.querySelectorAll('li')).map(li => (li.innerText || '').trim()).filter(Boolean) : [];
+      return { found: true, content: content.trim(), items: items };
+    }
+
+    return { found: false, content: '', items: [] };
+  });
+
+  if (!messageData.found) {
+    console.log('[get_messages] Fallback: trying to find message list directly');
+    const fallbackData = await page.evaluate(() => {
+      const messageList = document.querySelector('.msg-s-message-list-container');
+      if (messageList) {
+        const content = messageList.innerText || messageList.textContent || '';
+        const ul = messageList.querySelector('ul.msg-s-message-list-content');
+        const items = ul ? Array.from(ul.querySelectorAll('li')).map(li => (li.innerText || '').trim()).filter(Boolean) : [];
+        return { found: true, content: content.trim(), items: items };
+      }
+      return { found: false, content: '', items: [] };
     });
-    
-    if (newScrollHeight === previousScrollHeight) {
-      break;
+
+    if (fallbackData.found) {
+      return {
+        action: 'get_messages',
+        result: { status: 'success', message: fallbackData.content, items: fallbackData.items },
+        status: 'success'
+      };
     }
-    
-    previousScrollHeight = newScrollHeight;
-    scrollAttempts++;
+
+    return {
+      action: 'get_messages',
+      result: { status: 'error', message: `Could not find message container for ${username}` },
+      status: 'failed'
+    };
   }
-  
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const { content, items } = await page.evaluate(() => {
-    const messageList = document.querySelector('.msg-s-message-list');
-    if (messageList) {
-      const ul = messageList.querySelector('ul.msg-s-message-list-content');
-      const lis = ul ? Array.from(ul.querySelectorAll('li')) : [];
-      const texts = lis.map(li => (li.innerText || '').trim()).filter(Boolean);
-      return { content: (messageList.innerText || ''), items: texts };
-    }
-    const wrapper = document.querySelector('.msg-overlay-conversation-bubble__content-wrapper');
-    const list = wrapper ? wrapper.querySelector('.msg-s-message-list') : null;
-    const ul = list ? list.querySelector('ul.msg-s-message-list-content') : null;
-    const lis = ul ? Array.from(ul.querySelectorAll('li')) : [];
-    const texts = lis.map(li => (li.innerText || '').trim()).filter(Boolean);
-    return { content: (wrapper ? wrapper.innerText : ''), items: texts };
-  });
-  
+
+  console.log('[get_messages] Successfully extracted messages');
   return {
     action: 'get_messages',
-    result: { status: 'success', message: content },
+    result: { status: 'success', message: messageData.content, items: messageData.items },
     status: 'success'
   };
 }
@@ -412,3 +285,23 @@ async function getButtonByText(page, text, inMain = false) {
   
   return null;
 }
+
+async function closeAllConversationBubbles(page) {
+  console.log('[get_messages] Closing all conversation bubbles');
+  await page.evaluate(() => {
+    const allButtons = document.querySelectorAll('button');
+    const closeButtons = Array.from(allButtons).filter(btn => {
+      const useElement = btn.querySelector('svg use[href="#close-small"]');
+      return useElement !== null;
+    });
+    console.log('[get_messages] Found', closeButtons.length, 'close buttons');
+    closeButtons.forEach(btn => {
+      try {
+        btn.click();
+      } catch (e) {
+        console.log('[get_messages] Error clicking close button:', e.message);
+      }
+    });
+  });
+  await new Promise(resolve => setTimeout(resolve, 500));
+}

package/tools/human_typing.js

@@ -1,8 +1,23 @@
-export async function humanLikeType(element, text) {
+export async function humanLikeType(element, text, mistypeProbability = 0.05) {
   for (const char of text) {
+    const shouldMistype = Math.random() < mistypeProbability;
+    
+    if (shouldMistype && char !== ' ' && char !== '\n') {
+      const wrongChar = getRandomMistypeChar(char);
+      await element.type(wrongChar, { delay: 0 });
+      
+      const mistypeDelay = Math.floor(Math.random() * 200) + 50;
+      await new Promise(resolve => setTimeout(resolve, mistypeDelay));
+      
+      await element.press('Backspace', { delay: 0 });
+      
+      const correctionDelay = Math.floor(Math.random() * 200) + 50;
+      await new Promise(resolve => setTimeout(resolve, correctionDelay));
+    }
+    
     await element.type(char, { delay: 0 });
     
-    const delay = Math.floor(Math.random() * 100) + 50;
+    const delay = Math.floor(Math.random() * 200) + 50;
     await new Promise(resolve => setTimeout(resolve, delay));
   }
   
@@ -10,6 +25,26 @@ export async function humanLikeType(element, text) {
   await new Promise(resolve => setTimeout(resolve, finalDelay));
 }
 
+function getRandomMistypeChar(correctChar) {
+  const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+  const numbers = '012389';
+  const specialChars = '!@';
+  
+  let pool = alphabet;
+  if (/\d/.test(correctChar)) {
+    pool = numbers;
+  } else if (/[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/.test(correctChar)) {
+    pool = specialChars;
+  }
+  
+  let wrongChar;
+  do {
+    wrongChar = pool[Math.floor(Math.random() * pool.length)];
+  } while (wrongChar === correctChar && pool.length > 1);
+  
+  return wrongChar;
+}
+
 export async function readLinkedInCredentials() {
   const fs = (await import('fs')).default;
   const path = (await import('path')).default;