coffeeinabit 0.0.20 → 0.0.22

package/linkedin_automation.js

@@ -51,6 +51,31 @@ export class LinkedInAutomation {
     return delay;
   }
 
+  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);
+    return Boolean(this.browser && contextOpen && pageOpen);
+  }
+
+  ensureBrowserAvailable(context) {
+    if (this.hasActiveBrowser()) {
+      return true;
+    }
+    this.handleBrowserUnavailable(context);
+    return false;
+  }
+
+  handleBrowserUnavailable(context) {
+    console.warn(`[LinkedInAutomation] Browser unavailable during ${context}. Stopping background activities...`);
+    this.stopActionPolling();
+    this.stopScreenshotCapture();
+    this.stopAmbientMouseMovements();
+    if (this.status !== 'browser_unavailable') {
+      this.status = 'browser_unavailable';
+      this.emitStatus();
+    }
+  }
+
   getLinkedInSessionPath() {
     const sanitizedEmail = this.userEmail.replace(/[^a-zA-Z0-9]/g, '_');
     return path.join(this.linkedInSessionDir, `linkedin_auth_${sanitizedEmail}.json`);
@@ -183,7 +208,7 @@ export class LinkedInAutomation {
     }
   }
 
-  async startAutomation(headless = false) {
+  async startAutomation(headless = true) {
     try {
       console.log('[LinkedInAutomation] Starting automation...');
       this.headless = headless;
@@ -461,6 +486,9 @@ export class LinkedInAutomation {
   }
 
   startScreenshotCapture() {
+    if (!this.ensureBrowserAvailable('startScreenshotCapture')) {
+      return;
+    }
     console.log('[LinkedInAutomation] Starting screenshot capture...');
     
     this.screenshotInterval = setInterval(async () => {
@@ -477,7 +505,9 @@ export class LinkedInAutomation {
   }
 
   async captureScreenshot() {
-    if (!this.page) return;
+    if (!this.ensureBrowserAvailable('captureScreenshot')) {
+      return;
+    }
 
     try {
       const screenshot = await this.page.screenshot({
@@ -498,6 +528,9 @@ export class LinkedInAutomation {
 
     } catch (error) {
       console.error('[LinkedInAutomation] Failed to capture screenshot:', error.message);
+      if (typeof error.message === 'string' && error.message.includes('Target page, context or browser has been closed')) {
+        this.handleBrowserUnavailable('captureScreenshot_error');
+      }
     }
   }
 
@@ -506,6 +539,9 @@ export class LinkedInAutomation {
       console.log('[LinkedInAutomation] Action polling is already active, skipping...');
       return;
     }
+    if (!this.ensureBrowserAvailable('startActionPolling')) {
+      return;
+    }
 
     console.log('[LinkedInAutomation] Starting action polling with random intervals (20-40 seconds)...');
     this.isActionPollingActive = true;
@@ -540,6 +576,9 @@ export class LinkedInAutomation {
   }
 
   async pollForActions() {
+    if (!this.ensureBrowserAvailable('pollForActions')) {
+      return;
+    }
     try {
       console.log('[LinkedInAutomation] Polling for actions from backend...');
       
@@ -587,14 +626,48 @@ export class LinkedInAutomation {
   }
 
   async executeAction(action) {
-    console.log('[LinkedInAutomation] Starting execution of action:', action.action, 'ID:', action.action_id);
-    console.log('[LinkedInAutomation] Action parameters:', JSON.stringify(action.parameters, null, 2));
-    this.currentAction = action;
-    this.status = 'executing_action';
-    this.emitActionUpdate();
-    this.emitStatus();
+    const actionLogs = [];
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    const originalConsoleWarn = console.warn;
+    
+    const captureLog = (level, args) => {
+      const timestamp = new Date().toISOString();
+      const message = args.map(arg => {
+        if (typeof arg === 'string') return arg;
+        if (arg instanceof Error) return `${arg.message}\n${arg.stack}`;
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }).join(' ');
+      actionLogs.push({ timestamp, level, message });
+    };
+    
+    console.log = (...args) => {
+      captureLog('log', args);
+      originalConsoleLog.apply(console, args);
+    };
+    
+    console.error = (...args) => {
+      captureLog('error', args);
+      originalConsoleError.apply(console, args);
+    };
+    
+    console.warn = (...args) => {
+      captureLog('warn', args);
+      originalConsoleWarn.apply(console, args);
+    };
     
     try {
+      console.log('[LinkedInAutomation] Starting execution of action:', action.action, 'ID:', action.action_id);
+      console.log('[LinkedInAutomation] Action parameters:', JSON.stringify(action.parameters, null, 2));
+      this.currentAction = action;
+      this.status = 'executing_action';
+      this.emitActionUpdate();
+      this.emitStatus();
+      
       let result = null;
       
       switch (action.action) {
@@ -654,16 +727,34 @@ export class LinkedInAutomation {
       }
 
       console.log('[LinkedInAutomation] Reporting action result for ID:', action.action_id);
+      
+      if (result && typeof result === 'object') {
+        result.action_logs = actionLogs;
+      } else {
+        result = { ...result, action_logs: actionLogs };
+      }
+      
       await this.reportActionResult(action.action_id, result, action);
       console.log('[LinkedInAutomation] Action completed successfully:', action.action);
       
     } catch (error) {
       console.error('[LinkedInAutomation] Error executing action:', action.action, 'Error:', error.message);
-      await this.reportActionResult(action.action_id, { error: error.message }, action);
+      console.error('[LinkedInAutomation] Error stack:', error.stack);
+      
+      const errorResult = { 
+        error: error.message,
+        error_stack: error.stack,
+        action_logs: actionLogs
+      };
+      await this.reportActionResult(action.action_id, errorResult, action);
+    } finally {
+      console.log = originalConsoleLog;
+      console.error = originalConsoleError;
+      console.warn = originalConsoleWarn;
+      
+      this.currentAction = null;
+      this.emitActionUpdate();
     }
-    
-    this.currentAction = null;
-    this.emitActionUpdate();
   }
 
 
@@ -999,12 +1090,15 @@ export class LinkedInAutomation {
 
 
   startAmbientMouseMovements() {
-    if (this.ambientMouseTimeout || !this.page) {
+    if (this.ambientMouseTimeout) {
+      return;
+    }
+    if (!this.ensureBrowserAvailable('startAmbientMouseMovements')) {
       return;
     }
 
     const scheduleMove = async () => {
-      if (!this.page || !this.isRunning) {
+      if (!this.ensureBrowserAvailable('ambientMouseMovement') || !this.isRunning) {
         this.ambientMouseTimeout = null;
         return;
       }
@@ -1013,6 +1107,9 @@ export class LinkedInAutomation {
         await humanLikeAmbientMove(this.page);
       } catch (error) {
         console.warn('[LinkedInAutomation] Ambient mouse move failed:', error.message);
+        if (typeof error.message === 'string' && error.message.includes('Target page, context or browser has been closed')) {
+          this.handleBrowserUnavailable('ambientMouseMovement_error');
+        }
       }
 
       const nextDelay = Math.floor(Math.random() * 7000) + 6000;

package/package.json

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

package/public/dashboard.html

@@ -168,14 +168,12 @@
             const keepBrowserToggle = document.getElementById('keepBrowserToggle');
             
             if (keepBrowserEnabled === null) {
-                localStorage.setItem('keepBrowser', 'true');
+                localStorage.setItem('keepBrowser', 'false');
                 if (keepBrowserToggle) {
-                    keepBrowserToggle.checked = true;
-                }
-            } else if (keepBrowserEnabled === 'true') {
-                if (keepBrowserToggle) {
-                    keepBrowserToggle.checked = true;
+                    keepBrowserToggle.checked = false;
                 }
+            } else if (keepBrowserToggle) {
+                keepBrowserToggle.checked = keepBrowserEnabled === 'true';
             }
         }
 
@@ -334,7 +332,7 @@
                 startAutomationBtn.disabled = true;
                 startAutomationBtn.innerHTML = '<span class="spinner-border spinner-border-sm me-2"></span>Starting...';
                 
-                const keepBrowser = localStorage.getItem('keepBrowser') !== 'false';
+                const keepBrowser = localStorage.getItem('keepBrowser') === 'true';
                 
                 const response = await fetch('/api/automation/start', {
                     method: 'POST',

package/tools/comment_post.js

@@ -6,84 +6,147 @@ export async function executeCommentPost(page, action) {
   const postUrl = action.parameters?.url || action.url;
   const commentText = action.parameters?.comment_text || action.comment_text;
   
+  console.log('[CommentPost] Starting comment post action');
+  console.log('[CommentPost] Post URL:', postUrl);
+  console.log('[CommentPost] Comment text length:', commentText?.length || 0);
+  
   if (!postUrl || !commentText) {
+    console.error('[CommentPost] Missing required parameters');
     throw new Error('Missing url or comment_text for comment_post');
   }
   
-  await safeGoto(page, postUrl, {
-    waitUntil: 'domcontentloaded',
-    timeout: Math.floor(randomBetween(40000, 60000))
-  });
+  console.log('[CommentPost] Navigating to post URL');
+  console.log('[CommentPost] Will wait up to 60 seconds for page load');
+  try {
+    await safeGoto(page, postUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: Math.floor(randomBetween(40000, 60000))
+    });
+    console.log('[CommentPost] Post page loaded successfully');
+  } catch (error) {
+    console.error('[CommentPost] Navigation error:', error.message);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[CommentPost] Network timeout during post page navigation');
+      throw new Error(`Network timeout while navigating to post: ${error.message}`);
+    }
+    throw error;
+  }
   
-  await page.waitForSelector('main', { timeout: 10000 });
+  console.log('[CommentPost] Waiting for main content to load');
+  try {
+    await page.waitForSelector('main', { timeout: 10000 });
+    console.log('[CommentPost] Main content loaded');
+  } catch (error) {
+    console.error('[CommentPost] Main content not found:', error.message);
+    if (error.message.includes('timeout')) {
+      console.error('[CommentPost] Timeout waiting for main content');
+    }
+  }
   await waitRandom(1200, 3200, page);
+  console.log('[CommentPost] Scrolling to middle of page');
   await page.evaluate(() => { window.scrollTo(0, document.body.scrollHeight / 2); });
   await waitRandom(900, 2100, page);
   
+  console.log('[CommentPost] Searching for comment editor');
   let commentEditor = await page.locator('.comments-comment-box-comment__text-editor .ql-editor[contenteditable="true"]').first();
   
   if (await commentEditor.count() === 0) {
+    console.log('[CommentPost] Primary editor not found, trying alternative selector');
     const altEditor = await page.locator('[data-test-ql-editor-contenteditable="true"]').first();
     
     if (await altEditor.count() === 0) {
+      console.error('[CommentPost] Comment editor not found with any selector');
       return {
         action: 'comment_post',
-        result: { status: 'not_found', message: `Could not find comment editor for post: ${postUrl}` },
+        result: { 
+          status: 'not_found', 
+          message: `Could not find comment editor for post: ${postUrl}`,
+          details: 'Comment editor element not found, page may not have loaded or UI changed'
+        },
         status: 'failed'
       };
     }
     
+    console.log('[CommentPost] Alternative editor found, clicking and typing comment');
     await humanLikeClick(page, altEditor, { timeout: 5000 });
     await waitRandom(600, 900, page);
+    console.log('[CommentPost] Typing comment text');
     await humanLikeType(altEditor, commentText);
     await waitRandom(600, 900, page);
+    console.log('[CommentPost] Comment typed successfully, searching for submit button');
     
     let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
     
     if (await submitButton.count() > 0) {
+      console.log('[CommentPost] Submit button found, clicking');
       await humanLikeClick(page, submitButton, { timeout: 5000 });
       await waitRandom(900, 1600, page);
+      console.log('[CommentPost] Submit button clicked, comment should be posted');
     } else {
+      console.log('[CommentPost] Primary submit button not found, trying alternative');
       const altSubmitButton = await page.locator('button:has-text("Comment")').first();
       
       if (await altSubmitButton.count() > 0) {
+        console.log('[CommentPost] Alternative submit button found, clicking');
         await humanLikeClick(page, altSubmitButton, { timeout: 5000 });
         await waitRandom(900, 1600, page);
+        console.log('[CommentPost] Comment submit button clicked');
       } else {
+        console.error('[CommentPost] Submit button not found after typing comment');
+        console.error('[CommentPost] Comment may have been typed but not submitted');
         return {
           action: 'comment_post',
-          result: { status: 'submit_not_found', message: `Could not find Comment submit button for post: ${postUrl}` },
+          result: { 
+            status: 'submit_not_found', 
+            message: `Could not find Comment submit button for post: ${postUrl}`,
+            details: 'Comment was typed but submit button not found. Comment may not have been posted.'
+          },
           status: 'failed'
         };
       }
     }
   } else {
+    console.log('[CommentPost] Primary editor found, clicking and typing comment');
     await humanLikeClick(page, commentEditor, { timeout: 5000 });
     await waitRandom(600, 900, page);
+    console.log('[CommentPost] Typing comment text');
     await humanLikeType(commentEditor, commentText);
     await waitRandom(600, 900, page);
+    console.log('[CommentPost] Comment typed successfully, searching for submit button');
     
     let submitButton = await page.locator('.comments-comment-box__submit-button--cr').first();
     
     if (await submitButton.count() > 0) {
+      console.log('[CommentPost] Submit button found, clicking');
       await humanLikeClick(page, submitButton, { timeout: 5000 });
       await waitRandom(900, 1600, page);
+      console.log('[CommentPost] Submit button clicked, comment should be posted');
     } else {
+      console.log('[CommentPost] Primary submit button not found, trying alternative');
       const altSubmitButton = await page.locator('button:has-text("Comment")').first();
       
       if (await altSubmitButton.count() > 0) {
+        console.log('[CommentPost] Alternative submit button found, clicking');
         await humanLikeClick(page, altSubmitButton, { timeout: 5000 });
         await waitRandom(900, 1600, page);
+        console.log('[CommentPost] Comment submit button clicked');
       } else {
+        console.error('[CommentPost] Submit button not found after typing comment');
+        console.error('[CommentPost] Comment may have been typed but not submitted');
         return {
           action: 'comment_post',
-          result: { status: 'submit_not_found', message: `Could not find Comment submit button for post: ${postUrl}` },
+          result: { 
+            status: 'submit_not_found', 
+            message: `Could not find Comment submit button for post: ${postUrl}`,
+            details: 'Comment was typed but submit button not found. Comment may not have been posted.'
+          },
           status: 'failed'
         };
       }
     }
   }
   
+  console.log('[CommentPost] Comment post action completed successfully');
   return {
     action: 'comment_post',
     result: { status: 'success', message: `Comment successfully posted on post: ${postUrl}` },

package/tools/get_messages.js

@@ -14,11 +14,21 @@ export async function executeGetMessages(page, action) {
   
   const profileUrl = `https://www.linkedin.com/in/${username}`;
   console.log('[get_messages] Navigating to profile:', profileUrl);
-  await safeGoto(page, profileUrl, {
-    waitUntil: 'load',
-    timeout: Math.floor(randomBetween(40000, 60000))
-  });
-  console.log('[get_messages] Page loaded, URL:', page.url());
+  console.log('[get_messages] Will wait up to 60 seconds for page load');
+  try {
+    await safeGoto(page, profileUrl, {
+      waitUntil: 'load',
+      timeout: Math.floor(randomBetween(40000, 60000))
+    });
+    console.log('[get_messages] Page loaded successfully, URL:', page.url());
+  } catch (error) {
+    console.error('[get_messages] Navigation error:', error.message);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[get_messages] Network timeout during profile navigation');
+      throw new Error(`Network timeout while navigating to profile: ${error.message}`);
+    }
+    throw error;
+  }
   
   await page.waitForLoadState('domcontentloaded');
   await waitRandom(900, 1400, page);
@@ -32,12 +42,18 @@ export async function executeGetMessages(page, action) {
   console.log('[get_messages] Closing all conversation bubbles');
   await closeAllConversationBubbles(page);
 
+  console.log('[get_messages] Waiting for message button to appear');
   try {
     await page.waitForSelector('button[aria-label^="Message"], main button.artdeco-button--primary', { 
       timeout: 5000,
       state: 'attached'
     });
+    console.log('[get_messages] Message button selector found');
   } catch (error) {
+    console.warn('[get_messages] Message button selector not found immediately, will continue searching');
+    if (error.message.includes('timeout')) {
+      console.warn('[get_messages] Timeout waiting for message button selector');
+    }
   }
 
   await waitRandom(400, 650, page);

package/tools/get_profile.js

@@ -14,49 +14,85 @@ export async function executeGetProfile(page, action) {
 
   try{
     if (username === 'self') {
-      await safeGoto(page, 'https://www.linkedin.com/feed/', {
-        waitUntil: 'domcontentloaded',
-        timeout: 60000
-      });
+      console.log('[GetProfile] Fetching self profile, navigating to feed page');
+      try {
+        await safeGoto(page, 'https://www.linkedin.com/feed/', {
+          waitUntil: 'domcontentloaded',
+          timeout: 60000
+        });
+        console.log('[GetProfile] Feed page loaded successfully');
+      } catch (error) {
+        console.error('[GetProfile] Navigation error to feed page:', error.message);
+        if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+          console.error('[GetProfile] Network timeout during feed page navigation');
+          throw new Error(`Network timeout while navigating to feed: ${error.message}`);
+        }
+        throw error;
+      }
       
       await page.waitForLoadState('domcontentloaded');
       await new Promise(resolve => setTimeout(resolve, 2000));
 
+      console.log('[GetProfile] Searching for profile card on feed page');
       const profileCard = await page.locator('.profile-card-member-details').first();
       if (await profileCard.count() === 0) {
+        console.error('[GetProfile] Profile card not found on feed page');
         throw new Error('Could not find profile card on /feed');
       }
+      console.log('[GetProfile] Profile card found');
 
+      console.log('[GetProfile] Searching for profile name link');
       const profileNameLink = await profileCard.locator('.profile-card-name').first();
       if (await profileNameLink.count() === 0) {
+        console.error('[GetProfile] Profile name link not found');
         throw new Error('Could not find profile name link on /feed');
       }
+      console.log('[GetProfile] Profile name link found, clicking to navigate to profile');
 
       await profileNameLink.click();
       await page.waitForLoadState('domcontentloaded');
       await new Promise(resolve => setTimeout(resolve, 2000));
 
       const currentUrl = page.url();
+      console.log('[GetProfile] Extracted profile URL:', currentUrl);
       const match = currentUrl.match(/\/in\/([^/]+)/);
       if (!match) {
+        console.error('[GetProfile] Could not extract username from URL:', currentUrl);
         throw new Error('Could not extract username from profile URL');
       }
       username = match[1];
+      console.log('[GetProfile] Extracted username:', username);
     }
     
     const profileUrl = `https://www.linkedin.com/in/${username}`;
-    await safeGoto(page, profileUrl, {
-      waitUntil: 'domcontentloaded',
-      timeout: 60000
-    });
+    console.log('[GetProfile] Navigating to profile URL:', profileUrl);
+    console.log('[GetProfile] Will wait up to 60 seconds for page load');
+    try {
+      await safeGoto(page, profileUrl, {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+      });
+      console.log('[GetProfile] Profile page loaded successfully');
+    } catch (error) {
+      console.error('[GetProfile] Navigation error to profile:', error.message);
+      if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+        console.error('[GetProfile] Network timeout during profile page navigation');
+        throw new Error(`Network timeout while navigating to profile: ${error.message}`);
+      }
+      throw error;
+    }
 
     await page.waitForLoadState('domcontentloaded');
     await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log('[GetProfile] Page fully loaded, starting to scroll and extract content');
 
+    console.log('[GetProfile] Scrolling down to load profile content');
     await gentleScroll(page, 'down');
     await waitRandom(260, 480, page);
+    console.log('[GetProfile] Scrolling up');
     await gentleScroll(page, 'up');
     await waitRandom(240, 420, page);
+    console.log('[GetProfile] Extracting profile text content');
 
     const profileText = await page.evaluate(() => {
       const mainContent = document.querySelector('main');
@@ -75,21 +111,35 @@ export async function executeGetProfile(page, action) {
       return getAllText(mainContent);
     });
 
+    console.log('[GetProfile] Getting dropdown options and connection status');
     const { moreButtonOptions, isFirstDegreeConnection } = await getDropdownOptions(page);
+    console.log('[GetProfile] Dropdown options retrieved, isFirstDegreeConnection:', isFirstDegreeConnection);
 
     const recentActivityUrl = `https://www.linkedin.com/in/${username}/recent-activity/all/`;
+    console.log('[GetProfile] Navigating to recent activity page:', recentActivityUrl);
     let recentPosts = {};
     
     try {
-      await safeGoto(page, recentActivityUrl, {
-        waitUntil: 'domcontentloaded',
-        timeout: 60000
-      });
+      try {
+        await safeGoto(page, recentActivityUrl, {
+          waitUntil: 'domcontentloaded',
+          timeout: 60000
+        });
+        console.log('[GetProfile] Recent activity page loaded successfully');
+      } catch (error) {
+        console.error('[GetProfile] Navigation error to recent activity:', error.message);
+        if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+          console.error('[GetProfile] Network timeout during recent activity page navigation');
+        }
+        throw error;
+      }
 
       await page.waitForLoadState('domcontentloaded');
       await new Promise(resolve => setTimeout(resolve, 2000));
 
+      console.log('[GetProfile] Scrolling recent activity page to load posts');
       await gentleScroll(page, 'down', { stepRange: [140, 260], pauseRange: [80, 160], maxIterations: 40 });
+      console.log('[GetProfile] Extracting recent posts');
 
       recentPosts = await page.evaluate(() => {
         const mainContent = document.querySelector('main');
@@ -149,8 +199,13 @@ export async function executeGetProfile(page, action) {
       });
 
     } catch (error) {
+      console.warn('[GetProfile] Error fetching recent activity:', error.message);
+      if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+        console.warn('[GetProfile] Network timeout while fetching recent activity, continuing with profile data only');
+      }
     }
 
+    console.log('[GetProfile] Profile data extraction completed successfully');
     return {
       profileText,
       recentPosts,
@@ -159,7 +214,11 @@ export async function executeGetProfile(page, action) {
     };
 
   } catch (error) {
-    console.error('[GetProfile] Error:', error.message);
+    console.error('[GetProfile] Fatal error during profile retrieval:', error.message);
+    console.error('[GetProfile] Error stack:', error.stack);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[GetProfile] Network timeout detected - profile page may not have loaded completely');
+    }
     throw error;
   }
 }

package/tools/like_post.js

@@ -4,38 +4,71 @@ import { humanLikeClick, waitRandom, randomBetween } from './human_mouse.js';
 export async function executeLikePost(page, action) {
   const postUrl = action.parameters?.url || action.url;
   
+  console.log('[LikePost] Starting like post action');
+  console.log('[LikePost] Post URL:', postUrl);
+  
   if (!postUrl) {
+    console.error('[LikePost] Missing required parameter: url');
     throw new Error('Missing url for like_post');
   }
   
-  await safeGoto(page, postUrl, {
-    waitUntil: 'domcontentloaded',
-    timeout: 60000
-  });
+  console.log('[LikePost] Navigating to post URL');
+  console.log('[LikePost] Will wait up to 60 seconds for page load');
+  try {
+    await safeGoto(page, postUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: 60000
+    });
+    console.log('[LikePost] Post page loaded successfully');
+  } catch (error) {
+    console.error('[LikePost] Navigation error:', error.message);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[LikePost] Network timeout during post page navigation');
+      throw new Error(`Network timeout while navigating to post: ${error.message}`);
+    }
+    throw error;
+  }
   
+  console.log('[LikePost] Waiting for main content to load');
   const mainTimeout = Math.floor(randomBetween(5000, 9000));
-  await page.waitForSelector('main', { timeout: mainTimeout });
+  try {
+    await page.waitForSelector('main', { timeout: mainTimeout });
+    console.log('[LikePost] Main content loaded');
+  } catch (error) {
+    console.warn('[LikePost] Main content not found within timeout:', error.message);
+    if (error.message.includes('timeout')) {
+      console.warn('[LikePost] Timeout waiting for main content');
+    }
+  }
   await waitRandom(600, 3200, page);
   
+  console.log('[LikePost] Searching for Like button');
   let likeButton = await page.locator('main button[aria-label="React Like"], main button[aria-label="Unreact Like"]').first();
   
   if (await likeButton.count() === 0) {
+    console.log('[LikePost] Primary Like button not found, trying alternative selector');
     likeButton = await page.locator('main button:has-text("Like"), main button:has-text("Unlike")').first();
   }
   
   if (await likeButton.count() > 0) {
+    console.log('[LikePost] Like button found, checking current state');
     const ariaLabel = await likeButton.getAttribute('aria-label');
+    console.log('[LikePost] Like button aria-label:', ariaLabel);
     
     if (ariaLabel === 'Unreact Like') {
+      console.log('[LikePost] Post is already liked');
       return {
         action: 'like_post',
         result: { status: 'already_liked', message: `Post is already liked: ${postUrl}` },
         status: 'success'
       };
     } else if (ariaLabel === 'React Like') {
+      console.log('[LikePost] Post not liked yet, clicking Like button');
       await humanLikeClick(page, likeButton);
+      console.log('[LikePost] Like button clicked successfully');
       
       await waitRandom(700, 2400, page);
+      console.log('[LikePost] Like action completed');
       
       return {
         action: 'like_post',
@@ -43,6 +76,7 @@ export async function executeLikePost(page, action) {
         status: 'success'
       };
     } else {
+      console.warn('[LikePost] Could not determine Like button state, aria-label:', ariaLabel);
       return {
         action: 'like_post',
         result: { status: 'unknown', message: `Could not determine Like button state for post: ${postUrl}` },
@@ -50,9 +84,15 @@ export async function executeLikePost(page, action) {
       };
     }
   } else {
+    console.error('[LikePost] Like button not found with any selector');
+    console.error('[LikePost] Post may not have loaded or UI has changed');
     return {
       action: 'like_post',
-      result: { status: 'not_found', message: `Could not find Like button for post: ${postUrl}` },
+      result: { 
+        status: 'not_found', 
+        message: `Could not find Like button for post: ${postUrl}`,
+        details: 'Like button element not found, page may not have loaded or UI changed'
+      },
       status: 'failed'
     };
   }

package/tools/send_connection_request.js

@@ -9,41 +9,70 @@ export async function executeSendConnectionRequest(page, action) {
 
   try {
     const profileUrl = `https://www.linkedin.com/in/${username}`;
-    await safeGoto(page, profileUrl, {
-      waitUntil: 'load',
-      timeout: 60000
-    });
+    console.log('[SendConnectionRequest] Starting connection request for:', username);
+    console.log('[SendConnectionRequest] Navigating to profile:', profileUrl);
+    console.log('[SendConnectionRequest] Will wait up to 60 seconds for page load');
+    try {
+      await safeGoto(page, profileUrl, {
+        waitUntil: 'load',
+        timeout: 60000
+      });
+      console.log('[SendConnectionRequest] Profile page loaded successfully');
+    } catch (error) {
+      console.error('[SendConnectionRequest] Navigation error:', error.message);
+      if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+        console.error('[SendConnectionRequest] Network timeout during profile navigation');
+        throw new Error(`Network timeout while navigating to profile: ${error.message}`);
+      }
+      throw error;
+    }
 
     await page.waitForLoadState('load');
     await waitRandom(1700, 2600, page);
 
+    console.log('[SendConnectionRequest] Scrolling page and detecting connection status');
     await page.evaluate(() => { window.scrollTo(0, 300); });
     await waitRandom(600, 2500, page);
 
-    return await detectConnectionStatus(page, username);
+    const result = await detectConnectionStatus(page, username);
+    console.log('[SendConnectionRequest] Connection status detected:', result.status);
+    return result;
 
   } catch (error) {
-    console.error('[SendConnectionRequest] Error:', error.message);
+    console.error('[SendConnectionRequest] Fatal error:', error.message);
+    console.error('[SendConnectionRequest] Error stack:', error.stack);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[SendConnectionRequest] Network timeout detected');
+    }
     throw error;
   }
 }
 
 async function detectConnectionStatus(page, username) {
+  console.log('[SendConnectionRequest] Starting connection status detection');
   let inMain = true;
   
+  console.log('[SendConnectionRequest] Attempting to find and click Connect button');
   const connectResult = await handleConnectButtonClick(page, username, inMain, true);
   if (connectResult.status === 'success') {
+    console.log('[SendConnectionRequest] Connection request sent successfully');
     return connectResult;
   }
+  console.log('[SendConnectionRequest] Connect button not found or click failed, checking connection status');
 
+  console.log('[SendConnectionRequest] Checking for "More" button to access connection options');
   let moreActionsSelectors = await getButtonByText(page, 'More', inMain);
   if (!moreActionsSelectors || !(await moreActionsSelectors.isVisible())) {
+    console.log('[SendConnectionRequest] "More" button not found, trying "More actions"');
     moreActionsSelectors = await getButtonByText(page, 'More actions', inMain);
   }
   if (moreActionsSelectors && (await moreActionsSelectors.isVisible())) {
+    console.log('[SendConnectionRequest] Found More button, clicking to access dropdown');
     await clickWithRetries(page, moreActionsSelectors);
     await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
   }
+  
+  console.log('[SendConnectionRequest] Checking if already connected');
   let removeConnectionButton = await getButtonByText(page, 'Remove Connection', inMain);
   if (!removeConnectionButton) {
     removeConnectionButton = await getButtonByText(page, 'Remove', inMain);
@@ -52,13 +81,18 @@ async function detectConnectionStatus(page, username) {
     removeConnectionButton = await getButtonByText(page, 'Connected', inMain);
   }
   if (removeConnectionButton) {
+    console.log('[SendConnectionRequest] Already connected with', username);
     return { status: 'already_connected', message: `Already connected with ${username}.` };
   }
   
+  console.log('[SendConnectionRequest] Not connected, retrying Connect button click');
   const connectResultWithNote = await handleConnectButtonClick(page, username, inMain, true);
   if (connectResultWithNote.status === 'success') {
+    console.log('[SendConnectionRequest] Connection request sent successfully on retry');
     return connectResultWithNote;
   }
+  
+  console.log('[SendConnectionRequest] Checking if connection request is pending');
   let sentConnectionButton = await getButtonByText(page, 'Sent connection', inMain);
   if (!sentConnectionButton) {
     sentConnectionButton = await getButtonByText(page, 'Pending', inMain);
@@ -67,9 +101,11 @@ async function detectConnectionStatus(page, username) {
     sentConnectionButton = await getButtonByText(page, 'Invitation sent', inMain);
   }
   if (sentConnectionButton) {
+    console.log('[SendConnectionRequest] Connection request already pending for', username);
     return { status: 'pending', message: `Connection request already pending for ${username}.` };
   }
   
+  console.error('[SendConnectionRequest] Could not find Connect button or determine connection status');
   return { 
     status: 'not_found', 
     message: `Could not find Connect button for ${username}. Please analyze dom and decide what to do next.` 
@@ -77,51 +113,73 @@ async function detectConnectionStatus(page, username) {
 }
 
 async function handleConnectButtonClick(page, username, inMain = true, handleSendWithoutNote = true) {
+  console.log('[SendConnectionRequest] Searching for Connect button');
   let connectButton = await getButtonByText(page, 'Connect', inMain);
   if (!connectButton || !(await connectButton.isVisible())) {
+    console.log('[SendConnectionRequest] Connect button not found on first attempt, retrying');
     connectButton = await getButtonByText(page, 'Connect', inMain);
   }
 
   if (connectButton && (await connectButton.isVisible())) {
+    console.log('[SendConnectionRequest] Connect button found and visible, clicking');
     try {
       await clickWithRetries(page, connectButton);
+      console.log('[SendConnectionRequest] Connect button clicked successfully');
       
       if (handleSendWithoutNote) {
         await waitRandom(1700, 2600, page);
+        console.log('[SendConnectionRequest] Searching for "Send without a note" button');
         
         let sendWithoutNoteButton = await getButtonByText(page, 'Send without a note', false);
         if (!sendWithoutNoteButton) {
+          console.log('[SendConnectionRequest] Trying alternative text "without a note"');
           sendWithoutNoteButton = await getButtonByText(page, 'without a note', false);
         }
         if (!sendWithoutNoteButton) {
+          console.log('[SendConnectionRequest] Trying generic "Send" button');
           sendWithoutNoteButton = await getButtonByText(page, 'Send', false);
         }
         
         if (sendWithoutNoteButton && (await sendWithoutNoteButton.isVisible())) {
+          console.log('[SendConnectionRequest] Found send button, clicking');
           try {
             await clickWithRetries(page, sendWithoutNoteButton);
             await waitRandom(1700, 2600, page);
+            console.log('[SendConnectionRequest] Send button clicked, connection request should be sent');
             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}` };
+            console.error('[SendConnectionRequest] Error clicking Send button:', error.message);
+            if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+              console.error('[SendConnectionRequest] Network timeout while clicking Send button');
+            }
+            return { status: 'unclear', message: `Error clicking Send without a note button for ${username}: ${error.message}` };
           }
         } else {
+          console.log('[SendConnectionRequest] Send button not found, checking if modal is open');
           const existingModal = await page.locator('[data-test-modal-id="send-invite-modal"]').isVisible();
           if (existingModal) {
+            console.log('[SendConnectionRequest] Modal is open, assuming success');
             return { status: 'success', message: `Modal already open for ${username}` };
           } else {
+            console.warn('[SendConnectionRequest] No send button found and modal not open');
             return { status: 'unclear', message: `No send without a note button found for ${username}` };
           }
         }
       } else {
+        console.log('[SendConnectionRequest] Not handling send without note, waiting for auto-send');
         await waitRandom(4200, 6200, page);
         return { status: 'success', message: `Connection request sent successfully to ${username}` };
       }
     } catch (error) {
+      console.error('[SendConnectionRequest] Error clicking Connect button:', error.message);
+      if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+        console.error('[SendConnectionRequest] Network timeout while clicking Connect button');
+      }
       return { status: 'error', message: `Error clicking Connect button for ${username}: ${error.message}` };
     }
   }
   
+  console.warn('[SendConnectionRequest] Connect button not found or not visible');
   return { status: 'not_found', message: `Connect button not found for ${username}` };
 }
 

package/tools/send_messages.js

@@ -19,12 +19,22 @@ export async function executeSendMessages(page, action) {
   }
   
   const profileUrl = `https://www.linkedin.com/in/${username}`;
-  console.log('[send_messages] Navigating to profile:', profileUrl);
-  await safeGoto(page, profileUrl, {
-    waitUntil: 'load',
-    timeout: Math.floor(randomBetween(40000, 60000))
-  });
-  console.log('[send_messages] Page loaded, URL:', page.url());
+  console.log('[send_messages] Starting navigation to profile:', profileUrl);
+  console.log('[send_messages] Will wait up to 60 seconds for page load');
+  try {
+    await safeGoto(page, profileUrl, {
+      waitUntil: 'load',
+      timeout: Math.floor(randomBetween(40000, 60000))
+    });
+    console.log('[send_messages] Page loaded successfully, current URL:', page.url());
+  } catch (error) {
+    console.error('[send_messages] Navigation error:', error.message);
+    if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+      console.error('[send_messages] Network timeout during page navigation');
+      throw new Error(`Network timeout while navigating to profile: ${error.message}`);
+    }
+    throw error;
+  }
   
   await page.waitForLoadState('domcontentloaded');
   await waitRandom(800, 1400, page);
@@ -178,12 +188,12 @@ export async function executeSendMessages(page, action) {
     
     let editorReady = false;
     for (let attempt = 0; attempt < 5; attempt++) {
-      console.log('[send_messages] Editor preparation attempt', attempt + 1, 'of 5');
+      console.log('[send_messages] Editor search attempt', attempt + 1, 'of 5');
       try {
         const isVisible = await editor.isVisible({ timeout: 2000 }).catch(() => false);
         console.log('[send_messages] Editor visible:', isVisible);
         if (isVisible) {
-          console.log('[send_messages] Clicking editor');
+          console.log('[send_messages] Editor found, clicking to focus');
           await humanLikeClick(page, editor, { timeout: 3000, fallback: { force: true, timeout: 3000 } });
           await waitRandom(180, 260, page);
           
@@ -203,23 +213,34 @@ export async function executeSendMessages(page, action) {
           
           if (isFocused) {
             editorReady = true;
-            console.log('[send_messages] Editor ready!');
+            console.log('[send_messages] Editor ready and focused!');
             break;
+          } else {
+            console.warn('[send_messages] Editor not focused after click, will retry');
           }
+        } else {
+          console.log('[send_messages] Editor not visible, will retry');
         }
       } catch (e) {
-        console.log('[send_messages] Error preparing editor:', e.message);
+        console.warn('[send_messages] Error preparing editor on attempt', attempt + 1, '-', e.message);
+        if (e.message.includes('timeout') || e.message.includes('Timeout')) {
+          console.warn('[send_messages] Network timeout while searching for editor');
+        }
       }
       
       await waitRandom(260, 420, page);
-      console.log('[send_messages] Retrying to find message input');
-      await findAndClickMessageInput(page);
+      if (!editorReady) {
+        console.log('[send_messages] Retrying to find message input');
+        await findAndClickMessageInput(page);
+      }
     }
     
     if (!editorReady) {
-      console.warn('[send_messages] Editor not ready after 5 attempts, trying one more time');
+      console.warn('[send_messages] Editor not ready after 5 attempts, trying alternative method');
+      console.warn('[send_messages] Attempting to find and click message input using alternative selector');
       await findAndClickMessageInput(page);
       await waitRandom(420, 620, page);
+      console.log('[send_messages] Alternative method completed, checking if editor is now available');
     }
     
     console.log('[send_messages] Typing message:', message);
@@ -257,22 +278,30 @@ export async function executeSendMessages(page, action) {
     console.log('[send_messages] Clicking send button');
     const clickedSend = await clickSendButton(page);
     if (!clickedSend) {
-      console.error('[send_messages] Failed to click send button');
+      console.error('[send_messages] Failed to click send button after all attempts');
+      console.error('[send_messages] Message was typed but send button could not be found or clicked');
+      console.error('[send_messages] This may indicate a network timeout, page load issue, or UI change');
       return {
         action: 'send_messages',
-        result: { status: 'send_button_not_found', message: 'Could not find send button.' },
+        result: { 
+          status: 'send_button_not_found', 
+          message: 'Could not find send button. Message may have been typed but not sent.',
+          details: 'Button search timed out or button not found after message was typed'
+        },
         status: 'failed'
       };
     }
     console.log('[send_messages] Send button clicked successfully');
+    console.log('[send_messages] Waiting for message to be sent...');
     
     await waitRandom(520, 1500, page);
+    console.log('[send_messages] Wait completed after send button click');
   }
   
-  console.log('[send_messages] Closing all conversation bubbles');
+  console.log('[send_messages] All messages processed, closing conversation bubbles');
   await closeAllConversationBubbles(page);
   
-  console.log('[send_messages] Successfully completed!');
+  console.log('[send_messages] Successfully completed sending all messages to', username);
   return {
     action: 'send_messages',
     result: { status: 'success', message: `Message successfully sent to ${username}` },
@@ -331,23 +360,34 @@ async function closeAllConversationBubbles(page) {
 }
 
 async function clickSendButton(page) {
-  console.log('[send_messages] clickSendButton: Waiting 500ms');
+  console.log('[send_messages] clickSendButton: Starting button search, waiting 500ms');
   await waitRandom(420, 620, page);
   
   for (let attempt = 0; attempt < 10; attempt++) {
-    console.log('[send_messages] clickSendButton: Attempt', attempt + 1, 'of 10');
-    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;
+    console.log('[send_messages] clickSendButton: Attempt', attempt + 1, 'of 10 - searching for send button');
+    try {
+      const button = page.locator('.msg-form__send-button:not([disabled])').first();
+      const isVisible = await button.isVisible({ timeout: 3000 }).catch(() => false);
+      if (isVisible) {
+        console.log('[send_messages] clickSendButton: Send button found and visible, attempting click');
+        await humanLikeClick(page, button, { timeout: 3000 });
+        console.log('[send_messages] clickSendButton: Send button clicked successfully');
+        return true;
+      } else {
+        console.log('[send_messages] clickSendButton: Send button not visible, waiting before retry');
+      }
+    } catch (error) {
+      console.warn('[send_messages] clickSendButton: Error during attempt', attempt + 1, '-', error.message);
+      if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+        console.warn('[send_messages] clickSendButton: Network timeout detected during button search');
+      }
     }
     
     await waitRandom(260, 420, page);
   }
   
-  console.error('[send_messages] Failed to click send button after 10 attempts');
+  console.error('[send_messages] clickSendButton: Failed to click send button after 10 attempts');
+  console.error('[send_messages] clickSendButton: Possible causes: network timeout, button not found, page not loaded, or UI changed');
   return false;
 }