coffeeinabit 0.0.16 → 0.0.18

package/linkedin_automation.js

@@ -15,6 +15,7 @@ import { executeGetDailyLinkedInConnections } from './tools/get_daily_linkedin_c
 import { executeGetNewMessages } from './tools/get_new_messages.js';
 import { executeGetLinkedInUpdates } from './tools/get_linkedin_updates.js';
 import { safeGoto } from './tools/navigation.js';
+import { humanLikeAmbientMove, resetHumanMouseState } from './tools/human_mouse.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -37,6 +38,17 @@ export class LinkedInAutomation {
     this.userEmail = null;
     this.isActionPollingActive = false;
     this.linkedInSessionDir = getContextDirectory();
+    this.ambientMouseTimeout = null;
+  }
+
+  randomBetween(min, max) {
+    return min + Math.random() * (max - min);
+  }
+
+  async waitRandom(min = 350, max = 550) {
+    const delay = this.randomBetween(min, max);
+    await new Promise(resolve => setTimeout(resolve, delay));
+    return delay;
   }
 
   getLinkedInSessionPath() {
@@ -188,6 +200,7 @@ export class LinkedInAutomation {
       await this.launchBrowserAndLogin();
 
       this.setupPageListeners();
+      this.startAmbientMouseMovements();
 
       this.isRunning = true;
       this.status = 'running';
@@ -267,8 +280,7 @@ export class LinkedInAutomation {
         console.log('[LinkedInAutomation] Loading credentials...');
         const credentials = await readLinkedInCredentials();
 
-        
-        await new Promise(resolve => setTimeout(resolve, 10000));
+        await this.waitRandom(8000, 13000);
         
         console.log('[LinkedInAutomation] Waiting for login form...');
         await this.page.waitForSelector('#username', { timeout: 10000 });
@@ -320,7 +332,7 @@ export class LinkedInAutomation {
           if (this.currentUrl.includes('/feed')) {
             console.log('[LinkedInAutomation] Login successful! Detected /feed/ URL');
             
-            await new Promise(resolve => setTimeout(resolve, 2000));
+            await this.waitRandom(1500, 3200);
             
             const secondCheck = this.page.url();
             if (secondCheck.includes('/feed')) {
@@ -378,6 +390,7 @@ export class LinkedInAutomation {
   async closeBrowser() {
     try {
       console.log('[LinkedInAutomation] Closing browser...');
+      this.stopAmbientMouseMovements();
       
       if (this.page) {
         await this.page.close();
@@ -404,6 +417,7 @@ export class LinkedInAutomation {
 
       this.stopScreenshotCapture();
       this.stopActionPolling();
+      this.stopAmbientMouseMovements();
 
       await this.closeBrowser();
 
@@ -716,8 +730,6 @@ export class LinkedInAutomation {
 
   async pollForTaskResults(taskId, action, maxWaitTime = 4 * 60 * 1000) {
     const startTime = Date.now();
-    const pollInterval = 15000;
-
     console.log(`[LinkedInAutomation] Starting to poll for task results: ${taskId}`);
     
     this.status = 'waiting_for_backend_analysis';
@@ -759,7 +771,7 @@ export class LinkedInAutomation {
           console.error(`[LinkedInAutomation] Error polling task ${taskId}: ${response.status}`);
         }
 
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        await this.waitRandom(12000, 20000);
       } catch (error) {
         if (error.message && error.message.includes('404')) {
           console.log(`[LinkedInAutomation] Task ${taskId} not found yet, continuing to poll...`);
@@ -767,7 +779,7 @@ export class LinkedInAutomation {
           console.error(`[LinkedInAutomation] Error polling task ${taskId}:`, error.message);
         }
         
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        await this.waitRandom(12000, 20000);
       }
     }
 
@@ -852,6 +864,8 @@ export class LinkedInAutomation {
     
     await this.enablePerformanceMode();
     this.page = await this.context.newPage();
+    resetHumanMouseState();
+    // await this.installCursorHighlight();
 
     console.log('[LinkedInAutomation] Checking if user is already authenticated...');
     
@@ -898,6 +912,8 @@ export class LinkedInAutomation {
 
       await this.enablePerformanceMode();
       this.page = await this.context.newPage();
+      resetHumanMouseState();
+      // await this.installCursorHighlight();
       
       await safeGoto(this.page, currentUrl, { 
         waitUntil: 'domcontentloaded',
@@ -905,6 +921,7 @@ export class LinkedInAutomation {
       });
 
       this.setupPageListeners();
+      this.startAmbientMouseMovements();
       
       console.log('[LinkedInAutomation] Browser visibility updated successfully');
       
@@ -927,7 +944,7 @@ export class LinkedInAutomation {
         timeout: 30000
       });
 
-      await new Promise(resolve => setTimeout(resolve, 3000));
+      await this.waitRandom(2200, 4200);
 
       let verifyAttempts = 0;
       const maxVerifyAttempts = 3;
@@ -946,7 +963,7 @@ export class LinkedInAutomation {
           return true;
         }
 
-        await new Promise(resolve => setTimeout(resolve, 2000));
+        await this.waitRandom(2000, 3600);
         verifyAttempts++;
       }
 
@@ -970,6 +987,96 @@ export class LinkedInAutomation {
   }
 
 
+  startAmbientMouseMovements() {
+    if (this.ambientMouseTimeout || !this.page) {
+      return;
+    }
+
+    const scheduleMove = async () => {
+      if (!this.page || !this.isRunning) {
+        this.ambientMouseTimeout = null;
+        return;
+      }
+
+      try {
+        await humanLikeAmbientMove(this.page);
+      } catch (error) {
+        console.warn('[LinkedInAutomation] Ambient mouse move failed:', error.message);
+      }
+
+      const nextDelay = Math.floor(Math.random() * 7000) + 6000;
+      this.ambientMouseTimeout = setTimeout(scheduleMove, nextDelay);
+    };
+
+    const initialDelay = Math.floor(Math.random() * 4000) + 3000;
+    this.ambientMouseTimeout = setTimeout(scheduleMove, initialDelay);
+  }
+
+  stopAmbientMouseMovements() {
+    if (this.ambientMouseTimeout) {
+      clearTimeout(this.ambientMouseTimeout);
+      this.ambientMouseTimeout = null;
+    }
+  }
+
+  async installCursorHighlight() {
+    if (!this.page) return;
+
+    const script = `
+      (() => {
+        if (window.__ciabCursorHighlightInstalled) return;
+        window.__ciabCursorHighlightInstalled = true;
+
+        const ensureHighlight = () => {
+          if (document.querySelector('.ciab-cursor-highlight')) return;
+
+          const existingStyle = document.getElementById('ciab-cursor-style');
+          if (!existingStyle) {
+            const style = document.createElement('style');
+            style.id = 'ciab-cursor-style';
+            style.textContent = '.ciab-cursor-highlight{position:fixed;width:30px;height:30px;border:2px solid rgba(255,40,40,0.85);background:radial-gradient(rgba(255,0,0,0.35),rgba(255,30,30,0));border-radius:50%;pointer-events:none;transform:translate(-50%,-50%);transition:transform 0.06s ease-out,opacity 0.18s;z-index:2147483647;mix-blend-mode:normal;box-shadow:0 0 12px rgba(255,0,0,0.6);}';
+            document.head.appendChild(style);
+          }
+
+          const existingCursor = document.querySelector('.ciab-cursor-highlight');
+          const cursor = existingCursor || document.createElement('div');
+          cursor.className = 'ciab-cursor-highlight';
+          cursor.style.opacity = '0';
+          if (!existingCursor) {
+            document.body.appendChild(cursor);
+          }
+
+          let lastMove = performance.now();
+
+          const updatePosition = (event) => {
+            cursor.style.opacity = '1';
+            cursor.style.transform = 'translate(' + event.clientX + 'px,' + event.clientY + 'px)';
+            lastMove = performance.now();
+          };
+
+          document.addEventListener('mousemove', updatePosition, { passive: true });
+
+          const fadeLoop = () => {
+            if (performance.now() - lastMove > 1800) {
+              cursor.style.opacity = '0';
+            }
+            requestAnimationFrame(fadeLoop);
+          };
+          fadeLoop();
+        };
+
+        if (document.readyState === 'complete' || document.readyState === 'interactive') {
+          ensureHighlight();
+        } else {
+          document.addEventListener('DOMContentLoaded', ensureHighlight, { once: true });
+        }
+      })();
+    `;
+
+    await this.page.addInitScript(script);
+    await this.page.evaluate(script).catch(() => {});
+  }
+
   getStatus() {
     return {
       status: this.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "CoffeeInABit App",
   "main": "server.js",
   "type": "module",

package/tools/comment_post.js

@@ -1,4 +1,6 @@
 import { safeGoto } from './navigation.js';
+import { humanLikeClick, waitRandom, randomBetween } from './human_mouse.js';
+import { humanLikeType } from './human_typing.js';
 
 export async function executeCommentPost(page, action) {
   const postUrl = action.parameters?.url || action.url;
@@ -10,13 +12,13 @@ export async function executeCommentPost(page, action) {
   
   await safeGoto(page, postUrl, {
     waitUntil: 'domcontentloaded',
-    timeout: Math.floor(Math.random() * 20000) + 40000
+    timeout: Math.floor(randomBetween(40000, 60000))
   });
   
   await page.waitForSelector('main', { timeout: 10000 });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 10000) + 500));
+  await waitRandom(1200, 3200, page);
   await page.evaluate(() => { window.scrollTo(0, document.body.scrollHeight / 2); });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 4000) + 500));
+  await waitRandom(900, 2100, page);
   
   let commentEditor = await page.locator('.comments-comment-box-comment__text-editor .ql-editor[contenteditable="true"]').first();
   
@@ -31,22 +33,22 @@ export async function executeCommentPost(page, action) {
       };
     }
     
-    await altEditor.click();
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
-    await altEditor.fill(commentText);
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    await humanLikeClick(page, altEditor, { timeout: 5000 });
+    await waitRandom(600, 900, page);
+    await humanLikeType(altEditor, commentText);
+    await waitRandom(600, 900, page);
     
     let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
     
     if (await submitButton.count() > 0) {
-      await submitButton.click();
-      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      await humanLikeClick(page, submitButton, { timeout: 5000 });
+      await waitRandom(900, 1600, page);
     } else {
       const altSubmitButton = await page.locator('button:has-text("Comment")').first();
       
       if (await altSubmitButton.count() > 0) {
-        await altSubmitButton.click();
-        await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+        await humanLikeClick(page, altSubmitButton, { timeout: 5000 });
+        await waitRandom(900, 1600, page);
       } else {
         return {
           action: 'comment_post',
@@ -56,22 +58,22 @@ export async function executeCommentPost(page, action) {
       }
     }
   } else {
-    await commentEditor.click();
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
-    await commentEditor.fill(commentText);
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    await humanLikeClick(page, commentEditor, { timeout: 5000 });
+    await waitRandom(600, 900, page);
+    await humanLikeType(commentEditor, commentText);
+    await waitRandom(600, 900, page);
     
     let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
     
     if (await submitButton.count() > 0) {
-      await submitButton.click();
-      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      await humanLikeClick(page, submitButton, { timeout: 5000 });
+      await waitRandom(900, 1600, page);
     } else {
       const altSubmitButton = await page.locator('button:has-text("Comment")').first();
       
       if (await altSubmitButton.count() > 0) {
-        await altSubmitButton.click();
-        await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+        await humanLikeClick(page, altSubmitButton, { timeout: 5000 });
+        await waitRandom(900, 1600, page);
       } else {
         return {
           action: 'comment_post',

package/tools/get_messages.js

@@ -1,4 +1,5 @@
 import { safeGoto } from './navigation.js';
+import { humanLikeClick, waitRandom, randomBetween } from './human_mouse.js';
 
 export async function executeGetMessages(page, action) {
   console.log('[get_messages] Starting executeGetMessages');
@@ -15,18 +16,18 @@ export async function executeGetMessages(page, action) {
   console.log('[get_messages] Navigating to profile:', profileUrl);
   await safeGoto(page, profileUrl, {
     waitUntil: 'load',
-    timeout: Math.floor(Math.random() * 20000) + 40000
+    timeout: Math.floor(randomBetween(40000, 60000))
   });
   console.log('[get_messages] Page loaded, URL:', page.url());
   
   await page.waitForLoadState('domcontentloaded');
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  await new Promise(resolve => setTimeout(resolve, 2000));
+  await waitRandom(900, 1400, page);
+  await waitRandom(1600, 2600, page);
   
   await page.evaluate(() => { window.scrollTo(0, 0); });
-  await new Promise(resolve => setTimeout(resolve, 500));
+  await waitRandom(400, 650, page);
   await page.evaluate(() => { window.scrollTo(0, 300); });
-  await new Promise(resolve => setTimeout(resolve, 1000));
+  await waitRandom(900, 1500, page);
 
   console.log('[get_messages] Closing all conversation bubbles');
   await closeAllConversationBubbles(page);
@@ -39,7 +40,7 @@ export async function executeGetMessages(page, action) {
   } catch (error) {
   }
 
-  await new Promise(resolve => setTimeout(resolve, 500));
+  await waitRandom(400, 650, page);
   
   console.log('[get_messages] Checking for pending connection request');
   const pendingButton = await getButtonByText(page, 'Pending', true);
@@ -172,7 +173,7 @@ export async function executeGetMessages(page, action) {
     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.` },
+      result: { status: 'not_found_message_btn', message: `Could not find Message button on ${username}'s profile. Assume no messages or escalate_case_ask_user_to_provide_message_history` },
       status: 'failed'
     };
   }

package/tools/human_mouse.js

@@ -0,0 +1,187 @@
+export const mouseState = {
+  x: 0,
+  y: 0,
+  initialized: false
+};
+
+const easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+
+export const randomBetween = (min, max) => min + Math.random() * (max - min);
+
+const sleep = async (page, min = 20, max = 60) => {
+  const duration = randomBetween(min, max);
+  await page.waitForTimeout(duration);
+};
+
+const getViewportSize = async (page) => {
+  const viewportGetter = page.viewportSize;
+  if (typeof viewportGetter === 'function') {
+    const viewport = viewportGetter.call(page);
+    if (viewport) {
+      return viewport;
+    }
+  } else if (viewportGetter && viewportGetter.width && viewportGetter.height) {
+    return viewportGetter;
+  }
+  try {
+    return await page.evaluate(() => ({
+      width: window.innerWidth,
+      height: window.innerHeight
+    }));
+  } catch (_) {
+    return { width: 1280, height: 720 };
+  }
+};
+
+export const resetHumanMouseState = () => {
+  mouseState.initialized = false;
+  mouseState.x = 0;
+  mouseState.y = 0;
+};
+
+export const waitRandom = async (min, max, page) => {
+  const delay = randomBetween(min, max);
+  if (page && page.waitForTimeout) {
+    await page.waitForTimeout(delay);
+  } else {
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+  return delay;
+};
+
+export const humanLikeMouseMove = async (page, targetX, targetY, options = {}) => {
+  if (!page) {
+    return;
+  }
+
+  const speedRange = Array.isArray(options.speedRange) ? options.speedRange : [45, 110];
+
+  if (!mouseState.initialized) {
+    const viewport = await getViewportSize(page);
+    const originX = randomBetween(viewport.width * 0.25, viewport.width * 0.75);
+    const originY = randomBetween(viewport.height * 0.25, viewport.height * 0.75);
+    await page.mouse.move(originX, originY, { steps: 12 + Math.floor(Math.random() * 8) });
+    await sleep(page, 80, 140);
+    mouseState.initialized = true;
+    mouseState.x = originX;
+    mouseState.y = originY;
+  }
+
+  const startX = mouseState.x;
+  const startY = mouseState.y;
+
+  const distance = Math.hypot(targetX - startX, targetY - startY);
+  const autoSegments = Math.floor(distance / 120) + 6;
+  const segments = Math.max(6, Math.min(14, options.segments ?? autoSegments));
+  const jitter = options.jitter ?? Math.min(distance * 0.12, 18);
+
+  for (let i = 1; i <= segments; i++) {
+    const progress = i / segments;
+    const eased = easeInOutSine(progress);
+    const deviation = jitter * 0.6;
+    const intermediateX = startX + (targetX - startX) * eased + randomBetween(-deviation, deviation);
+    const intermediateY = startY + (targetY - startY) * eased + randomBetween(-deviation, deviation);
+    await page.mouse.move(intermediateX, intermediateY, {
+      steps: 3 + Math.floor(Math.random() * 4)
+    });
+    await sleep(page, speedRange[0], speedRange[1]);
+  }
+
+  const settleX = targetX + randomBetween(-2.2, 2.2);
+  const settleY = targetY + randomBetween(-2.2, 2.2);
+  await page.mouse.move(settleX, settleY, { steps: 2 + Math.floor(Math.random() * 3) });
+  await sleep(page, speedRange[0], speedRange[1]);
+
+  mouseState.x = settleX;
+  mouseState.y = settleY;
+};
+
+export const humanLikeClick = async (page, locator, options = {}) => {
+  if (!page || !locator) {
+    return false;
+  }
+
+  const timeout = options.timeout ?? 10000;
+  const postClickDelay = options.postClickDelay ?? [140, 280];
+  const fallbackOptions = options.fallback;
+  const button = options.button ?? 'left';
+  const hoverDelay = options.hoverDelay ?? [150, 300];
+
+  await locator.scrollIntoViewIfNeeded();
+  await locator.waitFor({ state: 'visible', timeout });
+
+  const handle = await locator.elementHandle();
+  if (!handle) {
+    if (fallbackOptions) {
+      await locator.click({ timeout, ...fallbackOptions });
+      return true;
+    }
+    return false;
+  }
+
+  let box = await handle.boundingBox();
+  if (!box) {
+    await page.waitForTimeout(50);
+    box = await handle.boundingBox();
+  }
+
+  if (!box) {
+    if (fallbackOptions) {
+      await locator.click({ timeout, ...fallbackOptions });
+      return true;
+    }
+    await locator.click({ timeout });
+    return true;
+  }
+
+  const paddingX = Math.min(box.width * 0.3, 12);
+  const paddingY = Math.min(box.height * 0.3, 12);
+
+  const targetX = randomBetween(box.x + paddingX, box.x + box.width - paddingX);
+  const targetY = randomBetween(box.y + paddingY, box.y + box.height - paddingY);
+
+  await humanLikeMouseMove(page, targetX, targetY, {
+    jitter: Math.min(box.width, box.height) * 0.15,
+    segments: 5 + Math.floor(Math.random() * 4)
+  });
+
+  for (let i = 0; i < 2; i++) {
+    const jitterX = targetX + randomBetween(-2.5, 2.5);
+    const jitterY = targetY + randomBetween(-2.5, 2.5);
+    await page.mouse.move(jitterX, jitterY, { steps: 2 + Math.floor(Math.random() * 3) });
+    await sleep(page, 15, 45);
+  }
+
+  await sleep(page, hoverDelay[0], hoverDelay[1]);
+  await page.mouse.down({ button });
+  await sleep(page, 60, 180);
+  await page.mouse.up({ button });
+
+  const delayRange = Array.isArray(postClickDelay) ? postClickDelay : [postClickDelay, postClickDelay];
+  await sleep(page, delayRange[0], delayRange[1]);
+
+  return true;
+};
+
+export const humanLikeAmbientMove = async (page) => {
+  if (!page) return;
+
+  let viewport = page.viewportSize();
+  if (!viewport) {
+    viewport = await page.evaluate(() => ({
+      width: window.innerWidth,
+      height: window.innerHeight
+    })).catch(() => ({ width: 1280, height: 720 }));
+  }
+
+  const safeMargin = 80;
+  const targetX = randomBetween(safeMargin, Math.max(safeMargin + 10, viewport.width - safeMargin));
+  const targetY = randomBetween(safeMargin, Math.max(safeMargin + 10, viewport.height - safeMargin));
+
+  await humanLikeMouseMove(page, targetX, targetY, {
+    jitter: 12,
+    segments: 4 + Math.floor(Math.random() * 4)
+  });
+  await sleep(page, 40, 120);
+};
+

package/tools/like_post.js

@@ -1,4 +1,5 @@
 import { safeGoto } from './navigation.js';
+import { humanLikeClick, waitRandom, randomBetween } from './human_mouse.js';
 
 export async function executeLikePost(page, action) {
   const postUrl = action.parameters?.url || action.url;
@@ -12,8 +13,9 @@ export async function executeLikePost(page, action) {
     timeout: 60000
   });
   
-  await page.waitForSelector('main', { timeout: Math.floor(Math.random() * 5000) + 5000 });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 3000) + 500));
+  const mainTimeout = Math.floor(randomBetween(5000, 9000));
+  await page.waitForSelector('main', { timeout: mainTimeout });
+  await waitRandom(600, 3200, page);
   
   let likeButton = await page.locator('main button[aria-label="React Like"], main button[aria-label="Unreact Like"]').first();
   
@@ -31,11 +33,9 @@ export async function executeLikePost(page, action) {
         status: 'success'
       };
     } else if (ariaLabel === 'React Like') {
-      await page.evaluate((button) => { 
-        if (button) button.click(); 
-      }, await likeButton.elementHandle());
+      await humanLikeClick(page, likeButton);
       
-      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      await waitRandom(700, 2400, page);
       
       return {
         action: 'like_post',

package/tools/send_connection_request.js

@@ -1,4 +1,5 @@
 import { safeGoto } from './navigation.js';
+import { humanLikeClick, waitRandom } from './human_mouse.js';
 
 export async function executeSendConnectionRequest(page, action) {
   let username = action.parameters?.username;
@@ -14,10 +15,10 @@ export async function executeSendConnectionRequest(page, action) {
     });
 
     await page.waitForLoadState('load');
-    await new Promise(resolve => setTimeout(resolve, 2000));
+    await waitRandom(1700, 2600, page);
 
     await page.evaluate(() => { window.scrollTo(0, 300); });
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+    await waitRandom(600, 2500, page);
 
     return await detectConnectionStatus(page, username);
 
@@ -40,7 +41,7 @@ async function detectConnectionStatus(page, username) {
     moreActionsSelectors = await getButtonByText(page, 'More actions', inMain);
   }
   if (moreActionsSelectors && (await moreActionsSelectors.isVisible())) {
-    await clickWithRetries(moreActionsSelectors);
+    await clickWithRetries(page, moreActionsSelectors);
     await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
   }
   let removeConnectionButton = await getButtonByText(page, 'Remove Connection', inMain);
@@ -83,10 +84,10 @@ async function handleConnectButtonClick(page, username, inMain = true, handleSen
 
   if (connectButton && (await connectButton.isVisible())) {
     try {
-      await clickWithRetries(connectButton);
+      await clickWithRetries(page, connectButton);
       
       if (handleSendWithoutNote) {
-        await new Promise(resolve => setTimeout(resolve, 2000));
+        await waitRandom(1700, 2600, page);
         
         let sendWithoutNoteButton = await getButtonByText(page, 'Send without a note', false);
         if (!sendWithoutNoteButton) {
@@ -98,8 +99,8 @@ async function handleConnectButtonClick(page, username, inMain = true, handleSen
         
         if (sendWithoutNoteButton && (await sendWithoutNoteButton.isVisible())) {
           try {
-            await clickWithRetries(sendWithoutNoteButton);
-            await new Promise(resolve => setTimeout(resolve, 2000));
+            await clickWithRetries(page, sendWithoutNoteButton);
+            await waitRandom(1700, 2600, page);
             return { status: 'success', message: `Connection request sent successfully to ${username}` };
           } catch (error) {
             return { status: 'unclear', message: `Error clicking Send without a note button for ${username}` };
@@ -113,7 +114,7 @@ async function handleConnectButtonClick(page, username, inMain = true, handleSen
           }
         }
       } else {
-        await new Promise(resolve => setTimeout(resolve, 5000));
+        await waitRandom(4200, 6200, page);
         return { status: 'success', message: `Connection request sent successfully to ${username}` };
       }
     } catch (error) {
@@ -164,17 +165,17 @@ async function getButtonByText(page, text, inMain = false) {
   return null;
 }
 
-async function clickWithRetries(locator, retries = 3) {
+async function clickWithRetries(page, locator, retries = 3) {
   for (let attempt = 0; attempt < retries; attempt++) {
     try {
       await locator.scrollIntoViewIfNeeded();
       await locator.waitFor({ state: 'visible', timeout: 5000 });
-      await locator.click({ trial: false, timeout: 15000 });
+      await humanLikeClick(page, locator);
       return true;
     } catch (_) {
-      await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+      await waitRandom(700 * (attempt + 1), 1200 * (attempt + 1), page);
     }
   }
-  await locator.click();
+  await humanLikeClick(page, locator);
   return true;
 }

package/tools/send_messages.js

@@ -1,5 +1,6 @@
 import { humanLikeType } from './human_typing.js';
 import { safeGoto } from './navigation.js';
+import { humanLikeClick, waitRandom, randomBetween } from './human_mouse.js';
 
 export async function executeSendMessages(page, action) {
   console.log('[send_messages] Starting executeSendMessages');
@@ -21,14 +22,14 @@ export async function executeSendMessages(page, action) {
   console.log('[send_messages] Navigating to profile:', profileUrl);
   await safeGoto(page, profileUrl, {
     waitUntil: 'load',
-    timeout: Math.floor(Math.random() * 20000) + 40000
+    timeout: Math.floor(randomBetween(40000, 60000))
   });
   console.log('[send_messages] Page loaded, URL:', page.url());
   
   await page.waitForLoadState('domcontentloaded');
-  await new Promise(resolve => setTimeout(resolve, 1000));
+  await waitRandom(800, 1400, page);
   await page.evaluate(() => { window.scrollTo(0, 300); });
-  await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+  await waitRandom(600, 2500, page);
   
   console.log('[send_messages] Closing all conversation bubbles');
   await closeAllConversationBubbles(page);
@@ -54,7 +55,7 @@ export async function executeSendMessages(page, action) {
       } catch (e) {
         console.log('[send_messages] Error checking elements:', e.message);
       }
-      await new Promise(r => setTimeout(r, 500));
+      await waitRandom(400, 650, page);
     }
     console.log('[send_messages] Conversation not opened after 10 attempts');
     return false;
@@ -68,9 +69,9 @@ export async function executeSendMessages(page, action) {
         if (await btn.isVisible().catch(() => false)) {
           console.log('[send_messages] Found Message button, clicking...');
           await btn.scrollIntoViewIfNeeded();
-          await new Promise(r => setTimeout(r, 300));
-          await btn.click({ timeout: 5000 });
-          await new Promise(r => setTimeout(r, 800));
+          await waitRandom(260, 420, page);
+          await humanLikeClick(page, btn, { timeout: 5000 });
+          await waitRandom(650, 950, page);
           return await checkConversationOpened();
         } else {
           console.log('[send_messages] Message button not visible');
@@ -87,9 +88,9 @@ export async function executeSendMessages(page, action) {
         if (await btn.isVisible().catch(() => false)) {
           console.log('[send_messages] Found send-privately button, clicking...');
           await btn.scrollIntoViewIfNeeded();
-          await new Promise(r => setTimeout(r, 300));
-          await btn.click({ timeout: 5000 });
-          await new Promise(r => setTimeout(r, 800));
+          await waitRandom(260, 420, page);
+          await humanLikeClick(page, btn, { timeout: 5000 });
+          await waitRandom(650, 950, page);
           return await checkConversationOpened();
         } else {
           console.log('[send_messages] send-privately button not visible');
@@ -110,9 +111,9 @@ export async function executeSendMessages(page, action) {
           if (!v) continue;
           console.log('[send_messages] Clicking candidate button');
           await btn.scrollIntoViewIfNeeded();
-          await new Promise(r => setTimeout(r, 200));
-          await btn.click({ timeout: 5000 });
-          await new Promise(r => setTimeout(r, 800));
+          await waitRandom(180, 320, page);
+          await humanLikeClick(page, btn, { timeout: 5000 });
+          await waitRandom(650, 950, page);
           if (await checkConversationOpened()) return true;
         }
       } catch (e) {
@@ -130,9 +131,9 @@ export async function executeSendMessages(page, action) {
           if (!isVisible) continue;
           console.log('[send_messages] Clicking Message button');
           await btn.scrollIntoViewIfNeeded();
-          await new Promise(r => setTimeout(r, 300));
-          await btn.click({ timeout: 5000 });
-          await new Promise(r => setTimeout(r, 800));
+          await waitRandom(260, 420, page);
+          await humanLikeClick(page, btn, { timeout: 5000 });
+          await waitRandom(650, 950, page);
           if (await checkConversationOpened()) return true;
         }
       } catch (e) {
@@ -156,7 +157,7 @@ export async function executeSendMessages(page, action) {
     console.error('[send_messages] Failed to open conversation - could not find Message button');
     return {
       action: 'send_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.` },
+      result: { status: 'not_found_message_btn', message: `Could not find Message button on ${username}'s profile. Assume no messages or escalate_case_ask_user_to_provide_message_history` },
       status: 'failed'
     };
   }
@@ -169,8 +170,8 @@ export async function executeSendMessages(page, action) {
     const message = messages[msgIndex];
     console.log('[send_messages] Processing message', msgIndex + 1, 'of', messages.length, ':', message);
     
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 100) + 500));
-    await new Promise(resolve => setTimeout(resolve, 200));
+    await waitRandom(520, 650, page);
+    await waitRandom(180, 260, page);
 
     const editor = page.locator('[aria-label="Write a message…"]').first();
     console.log('[send_messages] Looking for message editor by aria-label');
@@ -183,8 +184,8 @@ export async function executeSendMessages(page, action) {
         console.log('[send_messages] Editor visible:', isVisible);
         if (isVisible) {
           console.log('[send_messages] Clicking editor');
-          await editor.click({ timeout: 3000, force: true });
-          await new Promise(r => setTimeout(r, 200));
+          await humanLikeClick(page, editor, { timeout: 3000, fallback: { force: true, timeout: 3000 } });
+          await waitRandom(180, 260, page);
           
           console.log('[send_messages] Clearing and focusing editor');
           await editor.evaluate((el) => {
@@ -193,7 +194,7 @@ export async function executeSendMessages(page, action) {
             el.dispatchEvent(new Event('input', { bubbles: true }));
           });
           
-          await new Promise(r => setTimeout(r, 150));
+          await waitRandom(130, 210, page);
           
           const isFocused = await editor.evaluate((el) => {
             return document.activeElement === el;
@@ -210,7 +211,7 @@ export async function executeSendMessages(page, action) {
         console.log('[send_messages] Error preparing editor:', e.message);
       }
       
-      await new Promise(r => setTimeout(r, 300));
+      await waitRandom(260, 420, page);
       console.log('[send_messages] Retrying to find message input');
       await findAndClickMessageInput(page);
     }
@@ -218,12 +219,12 @@ export async function executeSendMessages(page, action) {
     if (!editorReady) {
       console.warn('[send_messages] Editor not ready after 5 attempts, trying one more time');
       await findAndClickMessageInput(page);
-      await new Promise(r => setTimeout(r, 500));
+      await waitRandom(420, 620, page);
     }
     
     console.log('[send_messages] Typing message:', message);
     await humanLikeType(editor, message);
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 300) + 300));
+    await waitRandom(320, 620, page);
     
     const textTyped = await editor.evaluate((el) => {
       const text = el.innerText || el.textContent || '';
@@ -233,16 +234,16 @@ export async function executeSendMessages(page, action) {
     
     if (!textTyped) {
       console.warn('[send_messages] Text not typed, retrying...');
-      await new Promise(resolve => setTimeout(resolve, 500));
-      await editor.click();
+      await waitRandom(420, 620, page);
+      await humanLikeClick(page, editor, { timeout: 3000 });
       await editor.evaluate((el) => {
         el.focus();
         el.dispatchEvent(new Event('focus', { bubbles: true }));
       });
-      await new Promise(resolve => setTimeout(resolve, 200));
+      await waitRandom(180, 260, page);
       console.log('[send_messages] Retrying to type message');
       await humanLikeType(editor, message);
-      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 300) + 300));
+      await waitRandom(320, 620, page);
       
       const textTypedRetry = await editor.evaluate((el) => {
         const text = el.innerText || el.textContent || '';
@@ -251,7 +252,7 @@ export async function executeSendMessages(page, action) {
       console.log('[send_messages] Text typed after retry:', textTypedRetry);
     }
     
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 200) + 200));
+    await waitRandom(220, 420, page);
     
     console.log('[send_messages] Clicking send button');
     const clickedSend = await clickSendButton(page);
@@ -265,7 +266,7 @@ export async function executeSendMessages(page, action) {
     }
     console.log('[send_messages] Send button clicked successfully');
     
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+    await waitRandom(520, 1500, page);
   }
   
   console.log('[send_messages] Closing all conversation bubbles');
@@ -282,102 +283,68 @@ export async function executeSendMessages(page, action) {
 async function typeLikeHuman(page, text) {
   for (const char of text) {
     await page.keyboard.type(char);
-    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 100) + 50));
+    await waitRandom(60, 160);
   }
 }
 
 async function findAndClickMessageInput(page) {
   console.log('[send_messages] findAndClickMessageInput: Waiting 1 second');
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
+  await waitRandom(900, 1200, page);
+
   console.log('[send_messages] findAndClickMessageInput: Looking for editor by aria-label');
-  const editorClicked = await page.evaluate(() => {
-    const editor = document.querySelector('[aria-label="Write a message…"]');
-    if (editor) {
-      console.log('[send_messages] Found editor, focusing and clicking');
-      editor.focus();
-      editor.click();
-      editor.dispatchEvent(new Event('focus', { bubbles: true }));
-      return true;
-    }
-    console.log('[send_messages] Editor not found');
-    return false;
-  });
-  
-  if (editorClicked) {
-    console.log('[send_messages] Editor clicked successfully');
-    await new Promise(resolve => setTimeout(resolve, 500));
+  const editorLocator = page.locator('[aria-label="Write a message…"]').first();
+  if (await editorLocator.isVisible().catch(() => false)) {
+    await humanLikeClick(page, editorLocator, { timeout: 3000 });
+    await waitRandom(420, 620, page);
     return;
   }
-  
+
   console.log('[send_messages] Editor not found, trying placeholder');
-  const placeholderClicked = await page.evaluate(() => {
-    const placeholder = document.querySelector('.msg-form__placeholder');
-    if (placeholder) {
-      console.log('[send_messages] Found placeholder, clicking');
-      placeholder.click();
-      const editor = document.querySelector('[aria-label="Write a message…"]');
-      if (editor) {
-        editor.focus();
-        editor.dispatchEvent(new Event('focus', { bubbles: true }));
-      }
-      return true;
+  const placeholderLocator = page.locator('.msg-form__placeholder').first();
+  if (await placeholderLocator.isVisible().catch(() => false)) {
+    await humanLikeClick(page, placeholderLocator, { timeout: 3000 });
+    await waitRandom(420, 620, page);
+    if (await editorLocator.isVisible().catch(() => false)) {
+      await humanLikeClick(page, editorLocator, { timeout: 3000 });
+      await waitRandom(420, 620, page);
     }
-    console.log('[send_messages] Placeholder not found');
-    return false;
-  });
-  
-  if (placeholderClicked) {
-    console.log('[send_messages] Placeholder clicked successfully');
-    await new Promise(resolve => setTimeout(resolve, 500));
-  } else {
-    console.warn('[send_messages] Neither editor nor placeholder found');
+    return;
   }
+
+  console.warn('[send_messages] Neither editor nor placeholder found');
 }
 
 async function closeAllConversationBubbles(page) {
   console.log('[send_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('[send_messages] Found', closeButtons.length, 'close buttons');
-    closeButtons.forEach(btn => {
-      try {
-        btn.click();
-      } catch (e) {
-        console.log('[send_messages] Error clicking close button:', e.message);
-      }
-    });
+  const closeButtons = page.locator('button').filter({
+    has: page.locator('svg use[href="#close-small"]')
   });
-  await new Promise(resolve => setTimeout(resolve, 500));
+  const count = await closeButtons.count();
+  for (let i = 0; i < count; i++) {
+    const btn = closeButtons.nth(i);
+    if (await btn.isVisible().catch(() => false)) {
+      await humanLikeClick(page, btn, { timeout: 2000 });
+      await waitRandom(220, 420, page);
+    }
+  }
+  await waitRandom(420, 620, page);
 }
 
 async function clickSendButton(page) {
   console.log('[send_messages] clickSendButton: Waiting 500ms');
-  await new Promise(resolve => setTimeout(resolve, 500));
+  await waitRandom(420, 620, page);
   
   for (let attempt = 0; attempt < 10; attempt++) {
     console.log('[send_messages] clickSendButton: Attempt', attempt + 1, 'of 10');
-    const clicked = await page.evaluate(() => {
-      const sendButton = document.querySelector('.msg-form__send-button:not([disabled])');
-      if (sendButton && !sendButton.disabled) {
-        console.log('[send_messages] Found enabled send button, clicking');
-        sendButton.click();
-        return true;
-      }
-      console.log('[send_messages] Send button not found or disabled');
-      return false;
-    });
-    
-    if (clicked) {
+    const button = page.locator('.msg-form__send-button:not([disabled])').first();
+    const isVisible = await button.isVisible().catch(() => false);
+    if (isVisible) {
+      await humanLikeClick(page, button, { timeout: 3000 });
       console.log('[send_messages] Send button clicked successfully');
       return true;
     }
     
-    await new Promise(resolve => setTimeout(resolve, 300));
+    await waitRandom(260, 420, page);
   }
   
   console.error('[send_messages] Failed to click send button after 10 attempts');