coffeeinabit 0.0.34 → 0.0.45

package/Makefile

@@ -1,3 +1,12 @@
 patch-and-publish:
+	@echo "Checking npm authentication..."
+	@npm whoami || (echo "Error: Not logged in to npm. Run 'npm login' first." && exit 1)
+	@echo "Authenticated as: $$(npm whoami)"
+	@echo "Verifying npm token in ~/.npmrc..."
+	@grep -q "//registry.npmjs.org/:_authToken=" ~/.npmrc || (echo "Error: No npm token found in ~/.npmrc" && exit 1)
+	@echo "Token found. Publishing..."
 	npm version patch
-	npm publish
+	npm publish --access public || (echo "" && echo "❌ Publish failed! If you see a 2FA error:" && echo "   1. Go to: https://www.npmjs.com/settings/kate_yan/tokens" && echo "   2. Create a 'Granular Access Token'" && echo "   3. Enable 'Bypass 2FA' permission" && echo "   4. Update ~/.npmrc with: //registry.npmjs.org/:_authToken=YOUR_NEW_TOKEN" && exit 1)
+
+stop:
+	pm2 stop "npx coffeeinabit" && pm2 delete "npx coffeeinabit" && pkill -9 -f "npm exec coffeeinabit"; pkill -9 -f "npx.*coffeeinabit"; pkill -9 -f "node.*coffeeinabit"

package/linkedin_automation.js

@@ -4,6 +4,7 @@ import fs from 'fs';
 import { getContextDirectory } from './tools/context_paths.js';
 import { fileURLToPath } from 'url';
 import { humanLikeType, readLinkedInCredentials } from './tools/human_typing.js';
+import { CloudAuth } from './cloud_auth.js';
 import { executeGetProfile } from './tools/get_profile.js';
 import { executeLikePost } from './tools/like_post.js';
 import { executeSendConnectionRequest } from './tools/send_connection_request.js';
@@ -39,6 +40,28 @@ export class LinkedInAutomation {
     this.isActionPollingActive = false;
     this.linkedInSessionDir = getContextDirectory();
     this.ambientMouseTimeout = null;
+    this.cloudAuth = new CloudAuth();
+    this._currentRefreshToken = null;
+    
+    // Lifecycle phases
+    this.PHASE_IDLE = 'idle';
+    this.PHASE_INITIALIZING = 'initializing';
+    this.PHASE_BROWSER_READY = 'browser_ready';
+    this.PHASE_AUTHENTICATING = 'authenticating';
+    this.PHASE_AUTHENTICATED = 'authenticated';
+    this.PHASE_RUNNING = 'running';
+    this.PHASE_STOPPING = 'stopping';
+    this.PHASE_ERROR = 'error';
+    
+    this.currentPhase = this.PHASE_IDLE;
+    this.authenticationPromise = null;
+    this.authenticationResolve = null;
+    this.authenticationReject = null;
+
+    // Polling/backoff configuration
+    this.pollIntervalMs = 2000; // starting interval (2s)
+    this.pollBackoffFactor = 1.5; // multiply each time when no work found
+    this.pollMaxMs = 5 * 60 * 1000; // 5 minutes max
   }
 
   randomBetween(min, max) {
@@ -51,6 +74,61 @@ export class LinkedInAutomation {
     return delay;
   }
 
+  transitionToPhase(newPhase) {
+    const oldPhase = this.currentPhase;
+    this.currentPhase = newPhase;
+    console.log(`[LinkedInAutomation] Phase transition: ${oldPhase} → ${newPhase}`);
+    
+    // Update status to match phase (for backward compatibility)
+    if (newPhase === this.PHASE_RUNNING) {
+      this.status = 'running';
+    } else if (newPhase === this.PHASE_AUTHENTICATED) {
+      this.status = 'linkedin_logged_in';
+    } else if (newPhase === this.PHASE_AUTHENTICATING) {
+      this.status = 'waiting_for_manual_login';
+    } else if (newPhase === this.PHASE_BROWSER_READY) {
+      this.status = 'browser_ready';
+    } else if (newPhase === this.PHASE_STOPPING) {
+      this.status = 'stopping';
+    } else if (newPhase === this.PHASE_IDLE) {
+      this.status = 'stopped';
+    } else if (newPhase === this.PHASE_ERROR) {
+      this.status = 'error';
+    }
+    
+    this.emitStatus();
+  }
+
+  async waitForPhase(targetPhase, timeoutMs = 120000) {
+    if (this.currentPhase === targetPhase) {
+      return true;
+    }
+    
+    console.log(`[LinkedInAutomation] Waiting for phase: ${targetPhase} (current: ${this.currentPhase})`);
+    
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      if (this.currentPhase === targetPhase) {
+        console.log(`[LinkedInAutomation] Reached target phase: ${targetPhase}`);
+        return true;
+      }
+      
+      if (this.currentPhase === this.PHASE_ERROR || this.currentPhase === this.PHASE_IDLE) {
+        console.log(`[LinkedInAutomation] Phase wait interrupted by ${this.currentPhase}`);
+        return false;
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    console.error(`[LinkedInAutomation] Timeout waiting for phase ${targetPhase}`);
+    return false;
+  }
+
+  isInPhaseOrLater(...phases) {
+    return phases.includes(this.currentPhase);
+  }
+
   hasActiveBrowser() {
     const contextOpen = this.context && typeof this.context.isClosed === 'function' ? !this.context.isClosed() : Boolean(this.context);
     const pageOpen = this.page && typeof this.page.isClosed === 'function' ? !this.page.isClosed() : Boolean(this.page);
@@ -211,32 +289,55 @@ export class LinkedInAutomation {
   async startAutomation(headless = true) {
     try {
       console.log('[LinkedInAutomation] Starting automation...');
+      
+      // Reset authentication promise
+      this.authenticationPromise = new Promise((resolve, reject) => {
+        this.authenticationResolve = resolve;
+        this.authenticationReject = reject;
+      });
+      
+      this.transitionToPhase(this.PHASE_INITIALIZING);
       this.headless = headless;
       this.originalHeadless = headless;
       this.needsManualLogin = false;
       console.log(`[LinkedInAutomation] Browser mode: ${headless ? 'headless' : 'visible'}`);
-      this.status = 'starting';
-      this.emitStatus();
 
       this.userEmail = this._currentUserEmail || 'default_user';
       console.log('[LinkedInAutomation] User email:', this.userEmail);
 
       console.log('[LinkedInAutomation] Launching browser for login...');
       await this.launchBrowserAndLogin();
-
+      
+      // launchBrowserAndLogin now ensures we're at BROWSER_READY phase
+      console.log('[LinkedInAutomation] Browser launched, waiting for authentication...');
+      
+      // Wait for authentication to complete (resolves when checkAndVerifySession succeeds)
+      const authSuccess = await Promise.race([
+        this.authenticationPromise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Authentication timeout')), 300000)) // 5 min timeout
+      ]);
+      
+      if (!authSuccess) {
+        throw new Error('Authentication failed');
+      }
+      
+      console.log('[LinkedInAutomation] Authentication successful, starting background activities...');
+      
+      // Now we're authenticated, mark as running and start background activities
+      this.isRunning = true;
+      this.transitionToPhase(this.PHASE_RUNNING);
+      
+      // Safe to start background activities now
       this.setupPageListeners();
       this.startAmbientMouseMovements();
-
-      this.isRunning = true;
-      this.status = 'running';
-      this.emitStatus();
-
       this.startScreenshotCapture();
+      
+      console.log('[LinkedInAutomation] Automation fully started and running');
 
     } catch (error) {
       console.error('[LinkedInAutomation] Failed to start automation:', error);
-      this.status = 'error';
-      this.emitStatus();
+      this.transitionToPhase(this.PHASE_ERROR);
+      this.isRunning = false;
       throw error;
     }
   }
@@ -406,6 +507,12 @@ export class LinkedInAutomation {
               console.log('[LinkedInAutomation] Starting action polling after successful login...');
               this.startActionPolling();
               
+              // Transition to AUTHENTICATED phase and resolve promise
+              this.transitionToPhase(this.PHASE_AUTHENTICATED);
+              if (this.authenticationResolve) {
+                this.authenticationResolve(true);
+              }
+              
               clearInterval(pollInterval);
             } else {
               console.log('[LinkedInAutomation] Second check failed - not on /feed/ anymore, continuing to wait...');
@@ -467,8 +574,15 @@ export class LinkedInAutomation {
   async stopAutomation() {
     try {
       console.log('[LinkedInAutomation] Stopping automation...');
-      this.status = 'stopping';
-      this.emitStatus();
+      this.transitionToPhase(this.PHASE_STOPPING);
+      this.isRunning = false;
+
+      // Reject any pending authentication promises
+      if (this.authenticationReject) {
+        this.authenticationReject(new Error('Automation stopped'));
+        this.authenticationResolve = null;
+        this.authenticationReject = null;
+      }
 
       this.stopScreenshotCapture();
       this.stopActionPolling();
@@ -476,13 +590,11 @@ export class LinkedInAutomation {
 
       await this.closeBrowser();
 
-      this.status = 'stopped';
-      this.emitStatus();
+      this.transitionToPhase(this.PHASE_IDLE);
 
     } catch (error) {
       console.error('[LinkedInAutomation] Error stopping automation:', error);
-      this.status = 'error';
-      this.emitStatus();
+      this.transitionToPhase(this.PHASE_ERROR);
     }
   }
 
@@ -571,11 +683,13 @@ export class LinkedInAutomation {
     if (!this.ensureBrowserAvailable('startActionPolling')) {
       return;
     }
-
-    console.log('[LinkedInAutomation] Starting action polling with random intervals (20-40 seconds)...');
+    console.log('[LinkedInAutomation] Starting action polling with backoff (max 5 minutes)...');
     this.isActionPollingActive = true;
-    
-    const pollWithRandomInterval = async () => {
+
+    // initialize a local current interval so we can grow it on each empty poll
+    let currentInterval = this.pollIntervalMs;
+
+    const pollWithBackoff = async () => {
       if (!this.isActionPollingActive) {
         console.log('[LinkedInAutomation] Action polling stopped, not scheduling next poll');
         return;
@@ -583,20 +697,28 @@ export class LinkedInAutomation {
 
       if (this.currentAction) {
         console.log('[LinkedInAutomation] Action in progress, skipping polling...');
-        const randomInterval = Math.floor(Math.random() * 20000) + 20000;
-        setTimeout(pollWithRandomInterval, randomInterval);
+        console.log('[LinkedInAutomation] Next poll in', Math.round(currentInterval / 1000), 'seconds');
+        setTimeout(pollWithBackoff, currentInterval);
         return;
       }
-      
-      await this.pollForActions();
-      
-      const randomInterval = Math.floor(Math.random() * 20000) + 20000;
-      console.log('[LinkedInAutomation] Next poll in', randomInterval / 1000, 'seconds');
-      
-      setTimeout(pollWithRandomInterval, randomInterval);
+
+      // pollForActions now returns true if actions were found and processed
+      const foundActions = await this.pollForActions();
+
+      if (foundActions) {
+        // reset backoff when we processed work
+        currentInterval = this.pollIntervalMs;
+      } else {
+        // increase interval (backoff) with slight jitter, cap to pollMaxMs
+        const jitter = Math.floor(Math.random() * 2000);
+        currentInterval = Math.min(this.pollMaxMs, Math.floor(currentInterval * this.pollBackoffFactor) + jitter);
+      }
+
+      console.log('[LinkedInAutomation] Next poll in', Math.round(currentInterval / 1000), 'seconds');
+      setTimeout(pollWithBackoff, currentInterval);
     };
-    
-    pollWithRandomInterval();
+
+    pollWithBackoff();
   }
 
   stopActionPolling() {
@@ -611,7 +733,7 @@ export class LinkedInAutomation {
     try {
       console.log('[LinkedInAutomation] Polling for actions from backend...');
       
-      const idToken = this.getAccessToken();
+      const idToken = await this.getAccessToken();
       if (!idToken) {
         console.error('[LinkedInAutomation] No id_token available for authentication');
         return;
@@ -638,19 +760,22 @@ export class LinkedInAutomation {
           for (const action of actions) {
             await this.executeAction(action);
           }
-        } else if (actions.length > 0) {
-          console.log('[LinkedInAutomation] Pending actions scheduled for future, continuing to poll...');
+          // Indicate there was work
+          return true;
         } else {
           console.log('[LinkedInAutomation] No actions to execute, continuing to poll...');
+          return false;
         }
       } else {
         console.error('[LinkedInAutomation] Failed to fetch actions. Status:', response.status, response.statusText);
         const errorText = await response.text();
         console.error('[LinkedInAutomation] Error response:', errorText);
+        return false;
       }
     } catch (error) {
       console.error('[LinkedInAutomation] Error polling for actions:', error.message);
       console.error('[LinkedInAutomation] Full error:', error);
+      return false;
     }
   }
 
@@ -700,63 +825,56 @@ export class LinkedInAutomation {
       
       let result = null;
       
+      // add esc to close any modals that might interfere
+      await this.page.keyboard.press('Escape');
+      await this.waitRandom(100, 2000);
+
       switch (action.action) {
         case 'get_profile':
           console.log('[LinkedInAutomation] Executing get_profile action...');
           result = await executeGetProfile(this.page, action);
-          console.log('[LinkedInAutomation] get_profile result:', result);
           break;
         case 'like_post':
           console.log('[LinkedInAutomation] Executing like_post action...');
           result = await executeLikePost(this.page, action);
-          console.log('[LinkedInAutomation] like_post result:', result);
           break;
         case 'send_connection_request':
           console.log('[LinkedInAutomation] Executing send_connection_request action...');
           result = await executeSendConnectionRequest(this.page, action);
-          console.log('[LinkedInAutomation] send_connection_request result:', result);
           break;
         case 'send_messages':
           console.log('[LinkedInAutomation] Executing send_messages action...');
           result = await executeSendMessages(this.page, action);
-          console.log('[LinkedInAutomation] send_messages result:', result);
           break;
         case 'comment_post':
           console.log('[LinkedInAutomation] Executing comment_post action...');
           result = await executeCommentPost(this.page, action);
-          console.log('[LinkedInAutomation] comment_post result:', result);
           break;
         case 'get_messages':
           console.log('[LinkedInAutomation] Executing get_messages action...');
           result = await executeGetMessages(this.page, action);
-          console.log('[LinkedInAutomation] get_messages result:', result);
           break;
         case 'get_linkedin_search_results':
           console.log('[LinkedInAutomation] Executing get_linkedin_search_results action...');
           result = await executeLinkedInSearch(this.page, action);
-          console.log('[LinkedInAutomation] get_linkedin_search_results result:', result);
           break;
         case 'get_daily_linkedin_connections':
           console.log('[LinkedInAutomation] Executing get_daily_linkedin_connections action...');
           result = await executeGetDailyLinkedInConnections(this.page, action);
-          console.log('[LinkedInAutomation] get_daily_linkedin_connections result:', result);
           break;
         case 'get_new_messages':
           console.log('[LinkedInAutomation] Executing get_new_messages action...');
-          result = await executeGetNewMessages(this.page, action, this.getAccessToken());
-          console.log('[LinkedInAutomation] get_new_messages result:', result);
+          result = await executeGetNewMessages(this.page, action, await this.getAccessToken());
           break;
         case 'get_linkedin_updates':
           console.log('[LinkedInAutomation] Executing get_linkedin_updates action...');
-          result = await executeGetLinkedInUpdates(this.page, action, this.getAccessToken());
-          console.log('[LinkedInAutomation] get_linkedin_updates result:', result);
+          result = await executeGetLinkedInUpdates(this.page, action, await this.getAccessToken());
           break;
         default:
           console.log('[LinkedInAutomation] Unknown action type:', action.action);
           result = { error: `Unknown action type: ${action.action}` };
       }
-
-      console.log('[LinkedInAutomation] Reporting action result for ID:', action.action_id);
+      console.log(`[LinkedInAutomation] ${action.action}: ${action.action_id} result: ${JSON.stringify(result)}`);
       
       if (result && typeof result === 'object') {
         result.action_logs = actionLogs;
@@ -790,10 +908,9 @@ export class LinkedInAutomation {
 
   async reportActionResult(actionId, result, action) {
     try {
-      console.log('[LinkedInAutomation] Sending result to backend for action ID:', actionId);
-      console.log('[LinkedInAutomation] Result data:', JSON.stringify(result, null, 2));
+      console.log(`[LinkedInAutomation] Reporting action result for ID: ${actionId}`);
       
-      const idToken = this.getAccessToken();
+      const idToken = await this.getAccessToken();
       if (!idToken) {
         console.error('[LinkedInAutomation] No id_token available for reporting result');
         return;
@@ -841,7 +958,7 @@ export class LinkedInAutomation {
 
     while (Date.now() - startTime < maxWaitTime) {
       try {
-        const idToken = this.getAccessToken();
+        const idToken = await this.getAccessToken();
         if (!idToken) {
           console.error('[LinkedInAutomation] No id_token available for polling');
           return;
@@ -936,8 +1053,46 @@ export class LinkedInAutomation {
     }
   }
 
-  getAccessToken() {
-    return this._currentAccessToken || null;
+  async getAccessToken() {
+    // Check if token exists
+    if (!this._currentAccessToken) {
+      console.error('[LinkedInAutomation] No access token available');
+      return null;
+    }
+
+    // Check if token is expired or expiring soon (within 5 minutes)
+    if (this.cloudAuth.isTokenExpired(this._currentAccessToken)) {
+      console.log('[LinkedInAutomation] Token expired or expiring soon, attempting refresh...');
+      
+      // Check if refresh token is available
+      if (!this._currentRefreshToken) {
+        console.error('[LinkedInAutomation] No refresh token available, cannot refresh');
+        return null;
+      }
+
+      // Attempt to refresh the token
+      try {
+        const result = await this.cloudAuth.refreshTokens(this._currentRefreshToken);
+        
+        if (result.success) {
+          console.log('[LinkedInAutomation] Token refreshed successfully');
+          this._currentAccessToken = result.tokens.idToken;
+          // Update refresh token if a new one was provided
+          if (result.tokens.refreshToken) {
+            this._currentRefreshToken = result.tokens.refreshToken;
+          }
+          return this._currentAccessToken;
+        } else {
+          console.error('[LinkedInAutomation] Token refresh failed:', result.error);
+          return null;
+        }
+      } catch (error) {
+        console.error('[LinkedInAutomation] Error during token refresh:', error.message);
+        return null;
+      }
+    }
+
+    return this._currentAccessToken;
   }
 
   getStorageStatePath() {
@@ -1037,6 +1192,9 @@ export class LinkedInAutomation {
     }
 
     resetHumanMouseState();
+    
+    // Transition to BROWSER_READY phase
+    this.transitionToPhase(this.PHASE_BROWSER_READY);
   }
 
   async updateBrowserVisibility(keepBrowser) {
@@ -1129,6 +1287,8 @@ export class LinkedInAutomation {
 
   async checkAndVerifySession() {
     try {
+      this.transitionToPhase(this.PHASE_AUTHENTICATING);
+      
       console.log('[LinkedInAutomation] Navigating to LinkedIn feed to verify persistent session...');
       await safeGoto(this.page, 'https://www.linkedin.com/feed/', { 
         waitUntil: 'domcontentloaded',
@@ -1146,11 +1306,16 @@ export class LinkedInAutomation {
 
         if (this.currentUrl.includes('/feed')) {
           console.log('[LinkedInAutomation] Session verified! Already logged in via persistent context.');
-          this.status = 'linkedin_logged_in';
-          this.emitStatus();
+          this.transitionToPhase(this.PHASE_AUTHENTICATED);
           
           console.log('[LinkedInAutomation] Starting action polling...');
           this.startActionPolling();
+          
+          // Resolve authentication promise to allow startAutomation to proceed
+          if (this.authenticationResolve) {
+            this.authenticationResolve(true);
+          }
+          
           return true;
         }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "coffeeinabit",
-  "version": "0.0.34",
-  "description": "CoffeeInABit App",
+  "version": "0.0.45",
+  "description": "coffeeinabit app",
   "main": "server.js",
   "type": "module",
   "keywords": [

package/public/dashboard.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>CoffeeInABit - Dashboard</title>
+    <title>coffeeinabit - Dashboard</title>
     <link rel="icon" type="image/png" href="/images/favicon.png">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css" rel="stylesheet">
@@ -13,8 +13,8 @@
     <nav class="navbar navbar-expand-lg glass-navbar">
         <div class="container-fluid">
             <a class="navbar-brand fw-bold" href="#">
-                <img src="/images/fav_clear.png" alt="CoffeeInABit" style="width: 35px; height: 35px; margin-bottom: 7px; vertical-align: middle;">
-                CoffeeInABit
+                <img src="/images/fav_clear.png" alt="coffeeinabit" style="width: 35px; height: 35px; margin-bottom: 7px; vertical-align: middle;">
+                coffeeinabit
             </a>
             <div class="navbar-nav ms-auto">
                 <div class="nav-item dropdown">

package/public/login.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>CoffeeInABit - Login</title>
+    <title>coffeeinabit - Login</title>
     <link rel="icon" type="image/png" href="/images/favicon.png">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css" rel="stylesheet">
@@ -16,8 +16,8 @@
                 <div class="glass-card">
                     <div class="text-center mb-4">
                         <h1 class="h3 mb-3 fw-bold" style="color: #ffffff;">
-                            <img src="/images/fav_clear.png" alt="CoffeeInABit" style="width: 75px; height: 75px; margin-bottom: 8px; vertical-align: middle;">
-                            CoffeeInABit
+                            <img src="/images/fav_clear.png" alt="coffeeinabit" style="width: 75px; height: 75px; margin-bottom: 8px; vertical-align: middle;">
+                            coffeeinabit
                         </h1>
                         <p class="text-muted">Sign in to your account to continue</p>
                     </div>
@@ -25,7 +25,7 @@
                     <div class="d-grid gap-2">
                         <button id="loginButton" class="glass-button btn-primary" onclick="loginToCloud()">
                             <i class="bi bi-cloud-arrow-up me-2"></i>
-                            Login to CoffeeInABit Cloud
+                            Login to coffeeinabit Cloud
                         </button>
                     </div>
                 </div>

package/server.js

@@ -145,6 +145,7 @@ app.post('/api/automation/start', async (req, res) => {
   try {
     const { headless = false } = req.body;
     linkedinAutomation._currentAccessToken = req.session.tokens.idToken;
+    linkedinAutomation._currentRefreshToken = req.session.tokens.refreshToken;
     linkedinAutomation._currentUserEmail = req.session.user.email;
     await linkedinAutomation.startAutomation(headless);
     res.json({ success: true, message: 'Automation started' });

package/tools/get_linkedin_updates.js

@@ -8,7 +8,20 @@ export async function executeGetLinkedInUpdates(page, action, accessToken) {
     const lastChecked = action.parameters?.last_checked || 0;
     
     console.log('[GetLinkedInUpdates] Fetching new messages...');
-    const messagesResult = await executeGetNewMessages(page, action, accessToken);
+    let messagesResult;
+    try {
+      const messagesTimeoutMs = 5 * 60 * 1000;
+      const timeoutPromise = new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('GetNewMessages timeout')), messagesTimeoutMs)
+      );
+      messagesResult = await Promise.race([
+        executeGetNewMessages(page, action, accessToken),
+        timeoutPromise
+      ]);
+    } catch (e) {
+      console.error('[GetLinkedInUpdates] get_new_messages failed or timed out:', e.message);
+      messagesResult = { newMessagesCount: 0, messages: [] };
+    }
     
     console.log('[GetLinkedInUpdates] Waiting before fetching connections...');
     await new Promise(resolve => setTimeout(resolve, 2000));

package/tools/get_new_messages.js

@@ -239,7 +239,7 @@ export async function executeGetNewMessages(page, action, accessToken) {
             
 
             for (let i = 0; i < 5; i++) {
-              await messageContainer.evaluate(function(el) {
+              await messageContainer.evaluate((el) => {
                 el.scrollBy({ top: -2000, behavior: 'smooth' });
               });
               console.log(`[GetNewMessages] Scrolled up -2000px (${i + 1}/5)`);
@@ -301,10 +301,13 @@ export async function executeGetNewMessages(page, action, accessToken) {
       }
     }
 
+    console.log('[GetNewMessages] Finished processing all conversations, waiting before cleanup...');
     await new Promise(resolve => setTimeout(resolve, 2000));
 
+    console.log('[GetNewMessages] Unrouting message handlers...');
     try {
       await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+      console.log('[GetNewMessages] Successfully unrouted message handlers');
     } catch (error) {
       console.log('[GetNewMessages] Error unrouting (non-critical):', error.message);
     }
@@ -338,25 +341,47 @@ export async function executeGetNewMessages(page, action, accessToken) {
     console.log('[GetNewMessages] Unique profiles to decode:', encodedUrlMap.size);
 
     const decodedUrlMap = new Map();
+    const maxDecodeAttempts = Math.min(encodedUrlMap.size, 50);
+    let decodeCount = 0;
+    
     for (const encodedUrl of encodedUrlMap.keys()) {
+      if (decodeCount >= maxDecodeAttempts) {
+        console.log(`[GetNewMessages] Reached max decode attempts (${maxDecodeAttempts}), skipping remaining profiles`);
+        break;
+      }
+      
       try {
-        await safeGoto(page, `https://www.linkedin.com/in/${encodedUrl}`, {
+        console.log(`[GetNewMessages] Decoding profile ${decodeCount + 1}/${encodedUrlMap.size}: ${encodedUrl}`);
+        
+        const decodePromise = safeGoto(page, `https://www.linkedin.com/in/${encodedUrl}`, {
           waitUntil: 'domcontentloaded',
           timeout: 30000
         });
-        await page.waitForLoadState('domcontentloaded');
+        
+        const timeoutPromise = new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Decode timeout')), 35000)
+        );
+        
+        await Promise.race([decodePromise, timeoutPromise]);
+        await page.waitForLoadState('domcontentloaded', { timeout: 10000 });
         await new Promise(resolve => setTimeout(resolve, 1000));
         
         const currentUrl = page.url();
         const match = currentUrl.match(/linkedin\.com\/in\/([^\/\?]+)/);
         if (match && match[1]) {
           decodedUrlMap.set(encodedUrl, match[1]);
+          console.log(`[GetNewMessages] Successfully decoded: ${encodedUrl} -> ${match[1]}`);
+        } else {
+          console.log(`[GetNewMessages] Could not extract URL from: ${currentUrl}`);
         }
+        decodeCount++;
       } catch (error) {
-        console.error(`[GetNewMessages] Failed to decode URL:`, error.message);
+        console.error(`[GetNewMessages] Failed to decode URL ${encodedUrl}:`, error.message);
+        decodeCount++;
+        continue;
       }
     }
-
+    
     let sentCount = 0;
     let failedCount = 0;
     let totalToSend = 0;