coffeeinabit 0.0.59 → 0.0.63

package/linkedin_automation.js

@@ -47,6 +47,8 @@ export class LinkedInAutomation {
     this.ambientMouseTimeout = null;
     this.cloudAuth = new CloudAuth();
     this._currentRefreshToken = null;
+    this._lastPageActivityAt = 0;
+    this._lastScreenshotUploadAt = 0;
     this._currentAccessToken = null; // Track access token explicitly
     
     // Action execution timeout (5 minutes)
@@ -60,6 +62,13 @@ export class LinkedInAutomation {
     
     // Token re-sync callback (set externally if available)
     this.tokenResyncCallback = null;
+
+    // Token sync-back callback (to persist refreshed tokens to session store)
+    this.tokenSyncBackCallback = null;
+
+    // Proactive token refresh timer
+    this._tokenRefreshInterval = null;
+    this._tokenRefreshIntervalMs = 45 * 60 * 1000; // 45 minutes
     
     // Lifecycle phases
     this.PHASE_IDLE = 'idle';
@@ -363,6 +372,7 @@ export class LinkedInAutomation {
       this.setupPageListeners();
       this.startAmbientMouseMovements();
       this.startScreenshotCapture();
+      this.startTokenRefreshTimer();
       
       logger.log('[LinkedInAutomation] Automation fully started and running');
 
@@ -638,6 +648,7 @@ export class LinkedInAutomation {
       this.stopScreenshotCapture();
       this.stopActionPolling();
       this.stopAmbientMouseMovements();
+      this.stopTokenRefreshTimer();
 
       await this.closeBrowser();
 
@@ -697,6 +708,19 @@ export class LinkedInAutomation {
     }
   }
 
+  _trackPageActivity() {
+    if (!this.page) return;
+    const mark = () => { this._lastPageActivityAt = Date.now(); };
+    for (const method of ['move', 'click', 'down', 'up']) {
+      const orig = this.page.mouse[method].bind(this.page.mouse);
+      this.page.mouse[method] = (...args) => { mark(); return orig(...args); };
+    }
+    for (const method of ['type', 'press', 'down', 'up', 'insertText']) {
+      const orig = this.page.keyboard[method].bind(this.page.keyboard);
+      this.page.keyboard[method] = (...args) => { mark(); return orig(...args); };
+    }
+  }
+
   async captureScreenshot() {
     if (!this.ensureBrowserAvailable('captureScreenshot')) {
       return;
@@ -719,8 +743,11 @@ export class LinkedInAutomation {
         timestamp: new Date().toISOString()
       });
 
-      // Fire-and-forget upload to S3
-      this.uploadScreenshotToS3(base64Screenshot, this.currentAction?.action_id);
+      // Only upload to S3 when an action is in progress and there was page activity since last upload
+      if (this.currentAction && this._lastPageActivityAt > this._lastScreenshotUploadAt) {
+        this._lastScreenshotUploadAt = Date.now();
+        this.uploadScreenshotToS3(base64Screenshot, this.currentAction.action_id);
+      }
 
     } catch (error) {
       logger.error('[LinkedInAutomation] Failed to capture screenshot:', error.message);
@@ -730,12 +757,15 @@ export class LinkedInAutomation {
     }
   }
 
-  async uploadScreenshotToS3(base64Screenshot, actionId) {
+  async uploadScreenshotToS3(base64Screenshot, actionId, retryCount = 0) {
     try {
       const idToken = await this.getAccessToken();
-      if (!idToken) return;
+      if (!idToken) {
+        logger.warn('[LinkedInAutomation] Screenshot upload skipped - no valid token');
+        return;
+      }
 
-      fetch('https://api.coffeeinabit.com/app/screenshots', {
+      const response = await fetch('https://api.coffeeinabit.com/app/screenshots', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -746,11 +776,21 @@ export class LinkedInAutomation {
           action_id: actionId || null,
           timestamp: Date.now()
         })
-      }).catch(err => {
-        logger.error('[LinkedInAutomation] Screenshot upload failed:', err.message);
       });
+
+      if (response.status === 401 && retryCount < 2) {
+        logger.warn('[LinkedInAutomation] Screenshot upload got 401, refreshing token and retrying...');
+        this._currentAccessToken = null;
+        return this.uploadScreenshotToS3(base64Screenshot, actionId, retryCount + 1);
+      }
     } catch (error) {
-      logger.error('[LinkedInAutomation] Screenshot upload error:', error.message);
+      if (retryCount < 2) {
+        const delay = 2000 * (retryCount + 1);
+        logger.warn(`[LinkedInAutomation] Screenshot upload failed (retry ${retryCount + 1}/2 in ${delay / 1000}s):`, error.message);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.uploadScreenshotToS3(base64Screenshot, actionId, retryCount + 1);
+      }
+      logger.error('[LinkedInAutomation] Screenshot upload failed after retries:', error.message);
     }
   }
 
@@ -940,6 +980,7 @@ export class LinkedInAutomation {
               if (refreshResult.tokens.refreshToken) {
                 this._currentRefreshToken = refreshResult.tokens.refreshToken;
               }
+              this.syncTokensBack();
               logger.log('[LinkedInAutomation] Token re-sync and refresh succeeded after 401, resetting failure counter');
               this.consecutiveAuthFailures = 0;
               this.authFailurePaused = false;
@@ -1040,7 +1081,11 @@ export class LinkedInAutomation {
       originalConsoleWarn.apply(console, args);
     };
     await closeAllConversationBubbles(this.page);
-    
+
+    // Pause background page operations so they don't compete with the action
+    this.stopScreenshotCapture();
+    this.stopAmbientMouseMovements();
+
     try {
       logger.log('[LinkedInAutomation] Starting execution of action:', action.action, 'ID:', action.action_id, 'Local time:', new Date().toLocaleString());
       logger.log('[LinkedInAutomation] Action parameters:', JSON.stringify(action.parameters, null, 2));
@@ -1150,24 +1195,31 @@ export class LinkedInAutomation {
       console.log = originalConsoleLog;
       console.error = originalConsoleError;
       console.warn = originalConsoleWarn;
-      
+
       this.currentAction = null;
       this.currentActionStartedAt = null;
       this.emitActionUpdate();
+
+      // Resume background page operations after action completes
+      if (this.isRunning && this.hasActiveBrowser()) {
+        this.startScreenshotCapture();
+        this.startAmbientMouseMovements();
+      }
     }
   }
 
 
-  async reportActionResult(actionId, result, action) {
+  async reportActionResult(actionId, result, action, retryCount = 0) {
+    const maxRetries = 3;
     try {
-      logger.log(`[LinkedInAutomation] Reporting action result for ID: ${actionId}`);
-      
+      logger.log(`[LinkedInAutomation] Reporting action result for ID: ${actionId}${retryCount > 0 ? ` (retry ${retryCount}/${maxRetries})` : ''}`);
+
       const idToken = await this.getAccessToken();
       if (!idToken) {
         logger.error('[LinkedInAutomation] No id_token available for reporting result');
         return;
       }
-      
+
       const response = await fetch('https://api.coffeeinabit.com/app/actions', {
         method: 'POST',
         headers: {
@@ -1179,11 +1231,11 @@ export class LinkedInAutomation {
           result: result
         })
       });
-      
+
       if (response.ok) {
         const responseData = await response.json();
         logger.log(`[LinkedInAutomation] Successfully reported action ${action.action} result. Response:`, responseData);
-        
+
         const { task_id, status } = responseData;
         if (task_id) {
           logger.log('[LinkedInAutomation] Received task_id:', task_id);
@@ -1197,7 +1249,13 @@ export class LinkedInAutomation {
         logger.error('[LinkedInAutomation] Error response:', errorText);
       }
     } catch (error) {
-      logger.error('[LinkedInAutomation] Error reporting action result:', error);
+      if (retryCount < maxRetries) {
+        const delay = Math.min(2000 * Math.pow(2, retryCount), 15000);
+        logger.warn(`[LinkedInAutomation] Error reporting action result (retry ${retryCount + 1}/${maxRetries} in ${delay / 1000}s):`, error.message);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.reportActionResult(actionId, result, action, retryCount + 1);
+      }
+      logger.error('[LinkedInAutomation] Error reporting action result after all retries:', error);
     }
   }
 
@@ -1313,6 +1371,58 @@ export class LinkedInAutomation {
     this.tokenResyncCallback = callback;
   }
 
+  /**
+   * Set a callback to persist refreshed tokens back to the session store
+   * @param {Function} callback - Function(idToken, refreshToken) that saves tokens to session
+   */
+  setTokenSyncBackCallback(callback) {
+    this.tokenSyncBackCallback = callback;
+  }
+
+  /**
+   * Persist refreshed tokens back to the session store so future resyncs get fresh tokens
+   */
+  async syncTokensBack() {
+    if (!this.tokenSyncBackCallback) return;
+    try {
+      await this.tokenSyncBackCallback(this._currentAccessToken, this._currentRefreshToken);
+    } catch (error) {
+      logger.error('[LinkedInAutomation] Error syncing tokens back to session:', error.message);
+    }
+  }
+
+  /**
+   * Start a periodic timer that proactively refreshes the JWT token before it expires.
+   * This prevents stale tokens from accumulating during long-running automation.
+   */
+  startTokenRefreshTimer() {
+    this.stopTokenRefreshTimer();
+    logger.log(`[LinkedInAutomation] Starting proactive token refresh timer (every ${this._tokenRefreshIntervalMs / 60000} min)`);
+
+    this._tokenRefreshInterval = setInterval(async () => {
+      if (!this.isRunning) return;
+      try {
+        logger.log('[LinkedInAutomation] Proactive token refresh triggered');
+        const token = await this.getAccessToken();
+        if (token) {
+          logger.log('[LinkedInAutomation] Proactive token refresh succeeded');
+        } else {
+          logger.error('[LinkedInAutomation] Proactive token refresh failed - no valid token');
+        }
+      } catch (error) {
+        logger.error('[LinkedInAutomation] Proactive token refresh error:', error.message);
+      }
+    }, this._tokenRefreshIntervalMs);
+  }
+
+  stopTokenRefreshTimer() {
+    if (this._tokenRefreshInterval) {
+      clearInterval(this._tokenRefreshInterval);
+      this._tokenRefreshInterval = null;
+      logger.log('[LinkedInAutomation] Token refresh timer stopped');
+    }
+  }
+
   /**
    * Attempt to re-sync tokens from external source (session, etc.)
    * @returns {Promise<boolean>} true if tokens were successfully re-synced
@@ -1338,12 +1448,13 @@ export class LinkedInAutomation {
             if (result.tokens.refreshToken) {
               this._currentRefreshToken = result.tokens.refreshToken;
             }
+            this.syncTokensBack();
           } else {
             logger.error('[LinkedInAutomation] Failed to refresh re-synced tokens:', result.error);
             return false;
           }
         }
-        
+
         return true;
       }
     } catch (error) {
@@ -1390,37 +1501,41 @@ export class LinkedInAutomation {
           if (result.tokens.refreshToken) {
             this._currentRefreshToken = result.tokens.refreshToken;
           }
+          // Persist refreshed tokens back to session store
+          this.syncTokensBack();
           // Reset failure counter on successful refresh
           this.consecutiveAuthFailures = 0;
           this.authFailurePaused = false;
           return this._currentAccessToken;
         } else {
           logger.error('[LinkedInAutomation] Token refresh failed:', result.error);
-          
+
           // Try one more time to re-sync before giving up
           logger.log('[LinkedInAutomation] Attempting token re-sync after refresh failure...');
           const resynced = await this.attemptTokenResync();
           if (resynced && !this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
             logger.log('[LinkedInAutomation] Token re-synced successfully after refresh failure');
+            this.syncTokensBack();
             this.consecutiveAuthFailures = 0;
             this.authFailurePaused = false;
             return this._currentAccessToken;
           }
-          
+
           return null;
         }
       } catch (error) {
         logger.error('[LinkedInAutomation] Error during token refresh:', error.message);
-        
+
         // Try re-sync one more time
         const resynced = await this.attemptTokenResync();
         if (resynced && !this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
           logger.log('[LinkedInAutomation] Token re-synced successfully after refresh error');
+          this.syncTokensBack();
           this.consecutiveAuthFailures = 0;
           this.authFailurePaused = false;
           return this._currentAccessToken;
         }
-        
+
         return null;
       }
     }
@@ -1574,7 +1689,8 @@ export class LinkedInAutomation {
     }
 
     resetHumanMouseState();
-    
+    this._trackPageActivity();
+
     // Transition to BROWSER_READY phase
     this.transitionToPhase(this.PHASE_BROWSER_READY);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.59",
+  "version": "0.0.63",
   "description": "coffeeinabit app",
   "main": "server.js",
   "type": "module",

package/server.js

@@ -95,6 +95,37 @@ const sessionStore = new FileStoreSession({
   retries: 0
 });
 
+// Set up token sync-back callback: when automation refreshes tokens, persist them to the session store
+linkedinAutomation.setTokenSyncBackCallback(async (idToken, refreshToken) => {
+  if (!linkedinAutomation._currentUserEmail || !idToken) return;
+
+  if (typeof sessionStore.all !== 'function') return;
+
+  return new Promise((resolve) => {
+    sessionStore.all((err, sessions) => {
+      if (err || !sessions) { resolve(); return; }
+
+      for (const sessionId in sessions) {
+        const sess = sessions[sessionId];
+        if (sess?.user?.email === linkedinAutomation._currentUserEmail && sess.tokens) {
+          sess.tokens.idToken = idToken;
+          if (refreshToken) sess.tokens.refreshToken = refreshToken;
+          sessionStore.set(sessionId, sess, (setErr) => {
+            if (setErr) {
+              logger.error('[Server] Failed to sync tokens back to session store:', setErr.message);
+            } else {
+              logger.log('[Server] Tokens synced back to session store for user:', sess.user.email);
+            }
+            resolve();
+          });
+          return;
+        }
+      }
+      resolve();
+    });
+  });
+});
+
 // Configure Express middleware
 app.use(express.json());
 app.use(express.static(path.join(__dirname, 'public')));

package/test/test_output_get_messages.json

@@ -1,7 +1,125 @@
 {
-  "threads": [],
-  "thread_count": 0,
-  "total_messages": 0,
-  "status": "no_history",
-  "message": "No previous messages found with natalie-grigorchuk-48277811. Conversation overlay shows \"New message\"."
+  "threads": [
+    {
+      "thread_id": "urn:li:messagingThread:2-ZGU3NTUyMzMtMTJkNy00NDIxLTk4MDgtYmYxNGIwOTQ5YjFmXzEwMA==",
+      "participants": [
+        {
+          "name": "Alena Borikova",
+          "uniq_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true
+        },
+        {
+          "name": "Kate Yanchenko",
+          "uniq_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false
+        }
+      ],
+      "last_activity_at": 1770139934759,
+      "last_activity_at_iso": "2026-02-03T17:32:14.759Z",
+      "messages": [
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "Hello!",
+          "timestamp": 1765865708197,
+          "timestamp_iso": "2025-12-16T06:15:08.197Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Alena Borikova",
+          "author_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true,
+          "text": "Hi hi ",
+          "timestamp": 1765867625215,
+          "timestamp_iso": "2025-12-16T06:47:05.215Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "Hello!",
+          "timestamp": 1765872088845,
+          "timestamp_iso": "2025-12-16T08:01:28.845Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "just testing",
+          "timestamp": 1765873430497,
+          "timestamp_iso": "2025-12-16T08:23:50.497Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "Hey, how are you?",
+          "timestamp": 1770138675922,
+          "timestamp_iso": "2026-02-03T17:11:15.922Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Alena Borikova",
+          "author_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true,
+          "text": "Fine, you? ❤️",
+          "timestamp": 1770138705220,
+          "timestamp_iso": "2026-02-03T17:11:45.220Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "Hey, how are you?",
+          "timestamp": 1770139276918,
+          "timestamp_iso": "2026-02-03T17:21:16.918Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Alena Borikova",
+          "author_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true,
+          "text": "I'm good",
+          "timestamp": 1770139300739,
+          "timestamp_iso": "2026-02-03T17:21:40.739Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Alena Borikova",
+          "author_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true,
+          "text": "Thanks for asking 😁❤️",
+          "timestamp": 1770139311452,
+          "timestamp_iso": "2026-02-03T17:21:51.452Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Kate Yanchenko",
+          "author_id": "ACoAABIyz2sB-O7ZtfsS5d8myngQBtR9JEKz_sY",
+          "is_self": false,
+          "text": "Hey, how are you?",
+          "timestamp": 1770139531176,
+          "timestamp_iso": "2026-02-03T17:25:31.176Z",
+          "network_intercepted_at": "2026-02-21T02:53:50.372Z"
+        },
+        {
+          "author": "Alena Borikova",
+          "author_id": "ACoAAB3lzOkB3_fTfG3OZRQMLMVLvIiQgowXmPk",
+          "is_self": true,
+          "text": "🐥❤️",
+          "timestamp": 1770139934759,
+          "timestamp_iso": "2026-02-03T17:32:14.759Z",
+          "network_intercepted_at": "2026-02-21T02:53:40.617Z"
+        }
+      ],
+      "message_count": 11
+    }
+  ],
+  "thread_count": 1,
+  "total_messages": 11
 }

package/tools/get_message_threads.js

@@ -148,9 +148,17 @@ function createRouteHandler(threadsMap, processedMessageKeys) {
     const url = route.request().url();
 
     if (url.includes('messengerConversations')) {
-      const response = await route.fetch();
+      let response;
       try {
-        const body = await response.text();
+        response = await route.fetch();
+      } catch (e) {
+        console.error('[GetMessageThreads] Fetch failed (messengerConversations):', e.message);
+        try { await route.continue(); } catch (_) { /* ignore */ }
+        return;
+      }
+      let body;
+      try {
+        body = await response.text();
         const data = JSON.parse(body);
         const dataKeys = Object.keys(data?.data || {});
         const prevSize = threadsMap.size;
@@ -159,21 +167,41 @@ function createRouteHandler(threadsMap, processedMessageKeys) {
       } catch (error) {
         console.error('[GetMessageThreads] Error parsing conversations:', error.message);
       }
-      try { await route.fulfill({ response }); } catch (e) { /* ignore */ }
+      try {
+        await route.fulfill({
+          status: response.status(),
+          headers: response.headers(),
+          body: body || ''
+        });
+      } catch (e) { /* ignore */ }
       return;
     }
 
     if (url.includes('messengerMessages')) {
-      const response = await route.fetch();
+      let response;
       try {
-        const body = await response.text();
+        response = await route.fetch();
+      } catch (e) {
+        console.error('[GetMessageThreads] Fetch failed (messengerMessages):', e.message);
+        try { await route.continue(); } catch (_) { /* ignore */ }
+        return;
+      }
+      let body;
+      try {
+        body = await response.text();
         const data = JSON.parse(body);
         const added = parseMessages(data, threadsMap, processedMessageKeys);
         console.log(`[GetMessageThreads] [${new Date().toISOString()}] Parsed ${added} messages`);
       } catch (error) {
         console.error('[GetMessageThreads] Error parsing messages:', error.message);
       }
-      try { await route.fulfill({ response }); } catch (e) { /* ignore */ }
+      try {
+        await route.fulfill({
+          status: response.status(),
+          headers: response.headers(),
+          body: body || ''
+        });
+      } catch (e) { /* ignore */ }
       return;
     }
 
@@ -188,9 +216,17 @@ function createRouteHandler(threadsMap, processedMessageKeys) {
  */
 async function clickConversationsToLoadMessages(page, threadsMap, cutoffTimestamp) {
   const maxThreads = 50;
+  const overallTimeout = 10 * 60 * 1000; // 10 minutes max for entire clicking phase
+  const perClickTimeout = 30000; // 30s max per conversation click
+  const startTime = Date.now();
   let clicked = 0;
 
   while (clicked < maxThreads) {
+    if (Date.now() - startTime > overallTimeout) {
+      console.log(`[GetMessageThreads] Overall timeout reached (${overallTimeout / 1000}s), stopping`);
+      break;
+    }
+
     const items = await page.locator('li.msg-conversation-listitem .msg-conversation-listitem__link').all();
 
     if (clicked === 0) {
@@ -215,38 +251,43 @@ async function clickConversationsToLoadMessages(page, threadsMap, cutoffTimestam
     const messagesBefore = countAllMessages(threadsMap);
 
     try {
-      await item.scrollIntoViewIfNeeded();
-      await waitRandom(200, 400);
-
-      const box = await item.boundingBox();
-      if (!box) {
-        console.log(`[GetMessageThreads] No bounding box for conversation ${clicked + 1}, skipping`);
-        clicked++;
-        continue;
-      }
-      // Click center-right of the item to avoid the checkbox on the left edge
-      const safeLeft = box.x + box.width * 0.4;
-      const safeRight = box.x + box.width * 0.9;
-      const targetX = safeLeft + Math.random() * (safeRight - safeLeft);
-      const targetY = box.y + box.height * 0.25 + Math.random() * (box.height * 0.5);
-      await page.mouse.click(targetX, targetY);
-      await waitRandom(800, 1500);
-
-      await new Promise(resolve => setTimeout(resolve, 2000));
-
-      // Dismiss bulk selection panel if it appeared
-      try {
-        const dismissBtn = page.locator('#msg-bulk-actions-panel-presenter-close-button');
-        if (await dismissBtn.count() > 0) {
-          console.log(`[GetMessageThreads] Bulk selection panel detected, dismissing...`);
-          await waitRandom(300, 700);
-          await humanLikeClick(page, dismissBtn, {
-            timeout: 5000,
-            postClickDelay: [200, 500],
-            fallback: { force: true }
-          });
-        }
-      } catch (e) { /* non-critical */ }
+      // Wrap the entire click operation in a timeout to prevent hanging
+      await Promise.race([
+        (async () => {
+          await item.scrollIntoViewIfNeeded();
+          await waitRandom(200, 400);
+
+          const box = await item.boundingBox();
+          if (!box) {
+            console.log(`[GetMessageThreads] No bounding box for conversation ${clicked + 1}, skipping`);
+            return;
+          }
+          // Click center-right of the item to avoid the checkbox on the left edge
+          const safeLeft = box.x + box.width * 0.4;
+          const safeRight = box.x + box.width * 0.9;
+          const targetX = safeLeft + Math.random() * (safeRight - safeLeft);
+          const targetY = box.y + box.height * 0.25 + Math.random() * (box.height * 0.5);
+          await page.mouse.click(targetX, targetY);
+          await waitRandom(800, 1500);
+
+          await new Promise(resolve => setTimeout(resolve, 2000));
+
+          // Dismiss bulk selection panel if it appeared
+          try {
+            const dismissBtn = page.locator('#msg-bulk-actions-panel-presenter-close-button');
+            if (await dismissBtn.count() > 0) {
+              console.log(`[GetMessageThreads] Bulk selection panel detected, dismissing...`);
+              await waitRandom(300, 700);
+              await humanLikeClick(page, dismissBtn, {
+                timeout: 5000,
+                postClickDelay: [200, 500],
+                fallback: { force: true }
+              });
+            }
+          } catch (e) { /* non-critical */ }
+        })(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Click operation timed out')), perClickTimeout))
+      ]);
 
       const messagesAfter = countAllMessages(threadsMap);
       const newMessages = messagesAfter - messagesBefore;
@@ -268,7 +309,7 @@ async function clickConversationsToLoadMessages(page, threadsMap, cutoffTimestam
     }
   }
 
-  console.log(`[GetMessageThreads] Clicked ${clicked} conversations total`);
+  console.log(`[GetMessageThreads] Clicked ${clicked} conversations total (elapsed: ${Math.round((Date.now() - startTime) / 1000)}s)`);
 }
 
 function countAllMessages(threadsMap) {
@@ -295,10 +336,17 @@ function getNewestMessageTimestamp(threadsMap, messagesBefore) {
  * Filter threads to only include messages from the last 24 hours
  * and build the final result structure
  */
-export function buildResult(threadsMap, cutoffTimestamp = 0) {
+export function buildResult(threadsMap, cutoffTimestamp = 0, targetUniqIds = null) {
   const result = [];
+  const targetSet = targetUniqIds && targetUniqIds.length > 0 ? new Set(targetUniqIds) : null;
 
   for (const [, thread] of threadsMap) {
+    // Filter to only threads with target participants
+    if (targetSet) {
+      const hasTarget = thread.participants.some(p => !p.isSelf && targetSet.has(p.uniqId));
+      if (!hasTarget) continue;
+    }
+
     const recentMessages = thread.messages
       .filter(m => m.deliveredAt >= cutoffTimestamp)
       .sort((a, b) => a.deliveredAt - b.deliveredAt);
@@ -352,7 +400,9 @@ export async function executeGetMessageThreads(page, action) {
   } else {
     cutoffTimestamp = Date.now() - (14 * 24 * 60 * 60 * 1000);
   }
+  const targetUniqIds = action.parameters?.target_uniq_ids || null;
   console.log(`[GetMessageThreads] Cutoff timestamp: ${cutoffTimestamp} (${new Date(cutoffTimestamp).toLocaleString()})`);
+  console.log(`[GetMessageThreads] Target uniq_ids: ${targetUniqIds ? targetUniqIds.length + ' users' : 'all (no filter)'}`);
 
   const threadsMap = new Map();
   const processedMessageKeys = new Set();
@@ -397,8 +447,8 @@ export async function executeGetMessageThreads(page, action) {
     // Cleanup route handler
     await cleanupRoute(page, routeHandler);
 
-    // Build result
-    const threads = buildResult(threadsMap, cutoffTimestamp);
+    // Build result (filtered to target users if provided)
+    const threads = buildResult(threadsMap, cutoffTimestamp, targetUniqIds);
 
     let totalMessages = 0;
     for (const t of threads) totalMessages += t.message_count;

package/tools/send_linkedin_message.js

@@ -91,7 +91,13 @@ export async function insertMessageText(messageInput, message, page) {
 export async function sendMessageInConversation(page, message, dryRun = false) {
     try {
         console.log('[send_linkedin_message] Finding message input...');
-        const messageInput = await page.waitForSelector('div[role="textbox"]', { timeout: 3000 });
+        let messageInput;
+        try {
+            messageInput = await page.waitForSelector('div[role="textbox"]', { timeout: 10000 });
+        } catch {
+            // Fallback: try the aria-label selector
+            messageInput = await page.waitForSelector('[aria-label="Write a message…"]', { timeout: 5000 }).catch(() => null);
+        }
         if (!messageInput) {
             throw new Error('Message input not found');
         }